?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vfs: check userland buffers before reading them.
[haiku.git] / src / apps / webpositive / BrowserWindow.cpp
blobbb0cdeb84bba3115ece8236556541157e279d27f
1 /*
2 * Copyright (C) 2007 Andrea Anzani <andrea.anzani@gmail.com>
3 * Copyright (C) 2007, 2010 Ryan Leavengood <leavengood@gmail.com>
4 * Copyright (C) 2009 Maxime Simon <simon.maxime@gmail.com>
5 * Copyright (C) 2010 Stephan Aßmus <superstippi@gmx.de>
6 * Copyright (C) 2010 Michael Lotz <mmlr@mlotz.ch>
7 * Copyright (C) 2010 Rene Gollent <rene@gollent.com>
8 * Copyright 2013-2015 Haiku, Inc. All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
20 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
27 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "BrowserWindow.h"
33
34 #include <Alert.h>
35 #include <Application.h>
36 #include <Bitmap.h>
37 #include <Button.h>
38 #include <Catalog.h>
39 #include <CheckBox.h>
40 #include <Clipboard.h>
41 #include <ControlLook.h>
42 #include <Debug.h>
43 #include <Directory.h>
44 #include <Entry.h>
45 #include <File.h>
46 #include <FilePanel.h>
47 #include <FindDirectory.h>
48 #include <GridLayoutBuilder.h>
49 #include <GroupLayout.h>
50 #include <GroupLayoutBuilder.h>
51 #include <IconMenuItem.h>
52 #include <Keymap.h>
53 #include <LayoutBuilder.h>
54 #include <Locale.h>
55 #include <ObjectList.h>
56 #include <MenuBar.h>
57 #include <MenuItem.h>
58 #include <MessageRunner.h>
59 #include <NodeInfo.h>
60 #include <NodeMonitor.h>
61 #include <Path.h>
62 #include <Roster.h>
63 #include <Screen.h>
64 #include <SeparatorView.h>
65 #include <Size.h>
66 #include <SpaceLayoutItem.h>
67 #include <StatusBar.h>
68 #include <StringView.h>
69 #include <TextControl.h>
70 #include <UnicodeChar.h>
71 #include <Url.h>
72
73 #include <map>
74 #include <stdio.h>
75
76 #include "AuthenticationPanel.h"
77 #include "BaseURL.h"
78 #include "BitmapButton.h"
79 #include "BookmarkBar.h"
80 #include "BrowserApp.h"
81 #include "BrowsingHistory.h"
82 #include "CredentialsStorage.h"
83 #include "IconButton.h"
84 #include "NavMenu.h"
85 #include "SettingsKeys.h"
86 #include "SettingsMessage.h"
87 #include "TabManager.h"
88 #include "URLInputGroup.h"
89 #include "WebPage.h"
90 #include "WebView.h"
91 #include "WebViewConstants.h"
92 #include "WindowIcon.h"
93
94
95 #undef B_TRANSLATION_CONTEXT
96 #define B_TRANSLATION_CONTEXT "WebPositive Window"
97
98
99 enum {
100 OPEN_LOCATION = 'open',
101 SAVE_PAGE = 'save',
102 GO_BACK = 'goba',
103 GO_FORWARD = 'gofo',
104 STOP = 'stop',
105 HOME = 'home',
106 GOTO_URL = 'goul',
107 RELOAD = 'reld',
108 SHOW_HIDE_BOOKMARK_BAR = 'shbb',
109 CLEAR_HISTORY = 'clhs',
110
111 CREATE_BOOKMARK = 'crbm',
112 SHOW_BOOKMARKS = 'shbm',
113
114 ZOOM_FACTOR_INCREASE = 'zfin',
115 ZOOM_FACTOR_DECREASE = 'zfdc',
116 ZOOM_FACTOR_RESET = 'zfrs',
117 ZOOM_TEXT_ONLY = 'zfto',
118
119 TOGGLE_FULLSCREEN = 'tgfs',
120 TOGGLE_AUTO_HIDE_INTERFACE_IN_FULLSCREEN = 'tgah',
121 CHECK_AUTO_HIDE_INTERFACE = 'cahi',
122
123 SHOW_PAGE_SOURCE = 'spgs',
124
125 EDIT_SHOW_FIND_GROUP = 'sfnd',
126 EDIT_HIDE_FIND_GROUP = 'hfnd',
127 EDIT_FIND_NEXT = 'fndn',
128 EDIT_FIND_PREVIOUS = 'fndp',
129 FIND_TEXT_CHANGED = 'ftxt',
130
131 SELECT_TAB = 'sltb',
132 };
133
134
135 static const int32 kModifiers = B_SHIFT_KEY | B_COMMAND_KEY
136 | B_CONTROL_KEY | B_OPTION_KEY | B_MENU_KEY;
137
138
139 static const char* kHandledProtocols[] = {
140 "http",
141 "https",
142 "file",
143 "about",
144 "data",
145 "gopher"
146 };
147
148
149 static BLayoutItem*
150 layoutItemFor(BView* view)
151 {
152 BLayout* layout = view->Parent()->GetLayout();
153 int32 index = layout->IndexOfView(view);
154 return layout->ItemAt(index);
155 }
156
157
158 class BookmarkMenu : public BNavMenu {
159 public:
160 BookmarkMenu(const char* title, BHandler* target, const entry_ref* navDir)
161 :
162 BNavMenu(title, B_REFS_RECEIVED, target)
163 {
164 // Add these items here already, so the shortcuts work even when
165 // the menu has never been opened yet.
166 _AddStaticItems();
167
168 SetNavDir(navDir);
169 }
170
171 virtual void AttachedToWindow()
172 {
173 RemoveItems(0, CountItems(), true);
174 ForceRebuild();
175 BNavMenu::AttachedToWindow();
176 if (CountItems() > 0)
177 AddItem(new BSeparatorItem(), 0);
178 _AddStaticItems();
179 DoLayout();
180 }
181
182 private:
183 void _AddStaticItems()
184 {
185 AddItem(new BMenuItem(B_TRANSLATE("Manage bookmarks"),
186 new BMessage(SHOW_BOOKMARKS), 'M'), 0);
187 AddItem(new BMenuItem(B_TRANSLATE("Bookmark this page"),
188 new BMessage(CREATE_BOOKMARK), 'B'), 0);
189 }
190 };
191
192
193 class PageUserData : public BWebView::UserData {
194 public:
195 PageUserData(BView* focusedView)
196 :
197 fFocusedView(focusedView),
198 fPageIcon(NULL),
199 fURLInputSelectionStart(-1),
200 fURLInputSelectionEnd(-1)
201 {
202 }
203
204 ~PageUserData()
205 {
206 delete fPageIcon;
207 }
208
209 void SetFocusedView(BView* focusedView)
210 {
211 fFocusedView = focusedView;
212 }
213
214 BView* FocusedView() const
215 {
216 return fFocusedView;
217 }
218
219 void SetPageIcon(const BBitmap* icon)
220 {
221 delete fPageIcon;
222 if (icon)
223 fPageIcon = new BBitmap(icon);
224 else
225 fPageIcon = NULL;
226 }
227
228 const BBitmap* PageIcon() const
229 {
230 return fPageIcon;
231 }
232
233 void SetURLInputContents(const char* text)
234 {
235 fURLInputContents = text;
236 }
237
238 const BString& URLInputContents() const
239 {
240 return fURLInputContents;
241 }
242
243 void SetURLInputSelection(int32 selectionStart, int32 selectionEnd)
244 {
245 fURLInputSelectionStart = selectionStart;
246 fURLInputSelectionEnd = selectionEnd;
247 }
248
249 int32 URLInputSelectionStart() const
250 {
251 return fURLInputSelectionStart;
252 }
253
254 int32 URLInputSelectionEnd() const
255 {
256 return fURLInputSelectionEnd;
257 }
258
259 private:
260 BView* fFocusedView;
261 BBitmap* fPageIcon;
262 BString fURLInputContents;
263 int32 fURLInputSelectionStart;
264 int32 fURLInputSelectionEnd;
265 };
266
267
268 class CloseButton : public BButton {
269 public:
270 CloseButton(BMessage* message)
271 :
272 BButton("close button", NULL, message),
273 fOverCloseRect(false)
274 {
275 // Button is 16x16 regardless of font size
276 SetExplicitMinSize(BSize(15, 15));
277 SetExplicitMaxSize(BSize(15, 15));
278 }
279
280 virtual void Draw(BRect updateRect)
281 {
282 BRect frame = Bounds();
283 BRect closeRect(frame.InsetByCopy(4, 4));
284 rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
285 float tint = B_DARKEN_1_TINT;
286
287 if (fOverCloseRect)
288 tint *= 1.4;
289 else
290 tint *= 1.2;
291
292 if (Value() == B_CONTROL_ON && fOverCloseRect) {
293 // Draw the button frame
294 be_control_look->DrawButtonFrame(this, frame, updateRect,
295 base, base, BControlLook::B_ACTIVATED
296 | BControlLook::B_BLEND_FRAME);
297 be_control_look->DrawButtonBackground(this, frame,
298 updateRect, base, BControlLook::B_ACTIVATED);
299 closeRect.OffsetBy(1, 1);
300 tint *= 1.2;
301 } else {
302 SetHighColor(base);
303 FillRect(updateRect);
304 }
305
306 // Draw the ×
307 base = tint_color(base, tint);
308 SetHighColor(base);
309 SetPenSize(2);
310 StrokeLine(closeRect.LeftTop(), closeRect.RightBottom());
311 StrokeLine(closeRect.LeftBottom(), closeRect.RightTop());
312 SetPenSize(1);
313 }
314
315 virtual void MouseMoved(BPoint where, uint32 transit,
316 const BMessage* dragMessage)
317 {
318 switch (transit) {
319 case B_ENTERED_VIEW:
320 fOverCloseRect = true;
321 Invalidate();
322 break;
323 case B_EXITED_VIEW:
324 fOverCloseRect = false;
325 Invalidate();
326 break;
327 case B_INSIDE_VIEW:
328 fOverCloseRect = true;
329 break;
330 case B_OUTSIDE_VIEW:
331 fOverCloseRect = false;
332 break;
333 }
334
335 BButton::MouseMoved(where, transit, dragMessage);
336 }
337
338 private:
339 bool fOverCloseRect;
340 };
341
342
343 // #pragma mark - BrowserWindow
344
345
346 BrowserWindow::BrowserWindow(BRect frame, SettingsMessage* appSettings,
347 const BString& url, BUrlContext* context, uint32 interfaceElements,
348 BWebView* webView)
349 :
350 BWebWindow(frame, kApplicationName,
351 B_DOCUMENT_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
352 B_AUTO_UPDATE_SIZE_LIMITS | B_ASYNCHRONOUS_CONTROLS),
353 fIsFullscreen(false),
354 fInterfaceVisible(false),
355 fMenusRunning(false),
356 fPulseRunner(NULL),
357 fVisibleInterfaceElements(interfaceElements),
358 fContext(context),
359 fAppSettings(appSettings),
360 fZoomTextOnly(true),
361 fShowTabsIfSinglePageOpen(true),
362 fAutoHideInterfaceInFullscreenMode(false),
363 fAutoHidePointer(false),
364 fBookmarkBar(NULL)
365 {
366 // Begin listening to settings changes and read some current values.
367 fAppSettings->AddListener(BMessenger(this));
368 // fZoomTextOnly = fAppSettings->GetValue("zoom text only", fZoomTextOnly);
369 fShowTabsIfSinglePageOpen = fAppSettings->GetValue(
370 kSettingsKeyShowTabsIfSinglePageOpen, fShowTabsIfSinglePageOpen);
371
372 fAutoHidePointer = fAppSettings->GetValue(kSettingsKeyAutoHidePointer,
373 fAutoHidePointer);
374
375 fNewWindowPolicy = fAppSettings->GetValue(kSettingsKeyNewWindowPolicy,
376 (uint32)OpenStartPage);
377 fNewTabPolicy = fAppSettings->GetValue(kSettingsKeyNewTabPolicy,
378 (uint32)OpenBlankPage);
379 fStartPageURL = fAppSettings->GetValue(kSettingsKeyStartPageURL,
380 kDefaultStartPageURL);
381 fSearchPageURL = fAppSettings->GetValue(kSettingsKeySearchPageURL,
382 kDefaultSearchPageURL);
383
384 // Create the interface elements
385 BMessage* newTabMessage = new BMessage(NEW_TAB);
386 newTabMessage->AddString("url", "");
387 newTabMessage->AddPointer("window", this);
388 newTabMessage->AddBool("select", true);
389 fTabManager = new TabManager(BMessenger(this), newTabMessage);
390
391 // Menu
392 #if INTEGRATE_MENU_INTO_TAB_BAR
393 BMenu* mainMenu = fTabManager->Menu();
394 #else
395 BMenu* mainMenu = new BMenuBar("Main menu");
396 #endif
397 BMenu* menu = new BMenu(B_TRANSLATE("Window"));
398 BMessage* newWindowMessage = new BMessage(NEW_WINDOW);
399 newWindowMessage->AddString("url", "");
400 BMenuItem* newItem = new BMenuItem(B_TRANSLATE("New window"),
401 newWindowMessage, 'N');
402 menu->AddItem(newItem);
403 newItem->SetTarget(be_app);
404 newItem = new BMenuItem(B_TRANSLATE("New tab"),
405 new BMessage(*newTabMessage), 'T');
406 menu->AddItem(newItem);
407 newItem->SetTarget(be_app);
408 menu->AddItem(new BMenuItem(B_TRANSLATE("Open location"),
409 new BMessage(OPEN_LOCATION), 'L'));
410 menu->AddSeparatorItem();
411 menu->AddItem(new BMenuItem(B_TRANSLATE("Close window"),
412 new BMessage(B_QUIT_REQUESTED), 'W', B_SHIFT_KEY));
413 menu->AddItem(new BMenuItem(B_TRANSLATE("Close tab"),
414 new BMessage(CLOSE_TAB), 'W'));
415 menu->AddItem(new BMenuItem(B_TRANSLATE("Save page as" B_UTF8_ELLIPSIS),
416 new BMessage(SAVE_PAGE), 'S'));
417 menu->AddSeparatorItem();
418 menu->AddItem(new BMenuItem(B_TRANSLATE("Downloads"),
419 new BMessage(SHOW_DOWNLOAD_WINDOW), 'D'));
420 menu->AddItem(new BMenuItem(B_TRANSLATE("Settings"),
421 new BMessage(SHOW_SETTINGS_WINDOW)));
422 menu->AddItem(new BMenuItem(B_TRANSLATE("Cookie manager"),
423 new BMessage(SHOW_COOKIE_WINDOW)));
424 menu->AddItem(new BMenuItem(B_TRANSLATE("Script console"),
425 new BMessage(SHOW_CONSOLE_WINDOW)));
426 BMenuItem* aboutItem = new BMenuItem(B_TRANSLATE("About"),
427 new BMessage(B_ABOUT_REQUESTED));
428 menu->AddItem(aboutItem);
429 aboutItem->SetTarget(be_app);
430 menu->AddSeparatorItem();
431 BMenuItem* quitItem = new BMenuItem(B_TRANSLATE("Quit"),
432 new BMessage(B_QUIT_REQUESTED), 'Q');
433 menu->AddItem(quitItem);
434 quitItem->SetTarget(be_app);
435 mainMenu->AddItem(menu);
436
437 menu = new BMenu(B_TRANSLATE("Edit"));
438 menu->AddItem(fCutMenuItem = new BMenuItem(B_TRANSLATE("Cut"),
439 new BMessage(B_CUT), 'X'));
440 menu->AddItem(fCopyMenuItem = new BMenuItem(B_TRANSLATE("Copy"),
441 new BMessage(B_COPY), 'C'));
442 menu->AddItem(fPasteMenuItem = new BMenuItem(B_TRANSLATE("Paste"),
443 new BMessage(B_PASTE), 'V'));
444 menu->AddSeparatorItem();
445 menu->AddItem(new BMenuItem(B_TRANSLATE("Find"),
446 new BMessage(EDIT_SHOW_FIND_GROUP), 'F'));
447 menu->AddItem(fFindPreviousMenuItem
448 = new BMenuItem(B_TRANSLATE("Find previous"),
449 new BMessage(EDIT_FIND_PREVIOUS), 'G', B_SHIFT_KEY));
450 menu->AddItem(fFindNextMenuItem = new BMenuItem(B_TRANSLATE("Find next"),
451 new BMessage(EDIT_FIND_NEXT), 'G'));
452 mainMenu->AddItem(menu);
453 fFindPreviousMenuItem->SetEnabled(false);
454 fFindNextMenuItem->SetEnabled(false);
455
456 menu = new BMenu(B_TRANSLATE("View"));
457 menu->AddItem(new BMenuItem(B_TRANSLATE("Reload"), new BMessage(RELOAD),
458 'R'));
459 // the label will be replaced with the appropriate text later on
460 fBookmarkBarMenuItem = new BMenuItem(B_TRANSLATE("Show bookmark bar"),
461 new BMessage(SHOW_HIDE_BOOKMARK_BAR));
462 menu->AddItem(fBookmarkBarMenuItem);
463 menu->AddSeparatorItem();
464 menu->AddItem(new BMenuItem(B_TRANSLATE("Increase size"),
465 new BMessage(ZOOM_FACTOR_INCREASE), '+'));
466 menu->AddItem(new BMenuItem(B_TRANSLATE("Decrease size"),
467 new BMessage(ZOOM_FACTOR_DECREASE), '-'));
468 menu->AddItem(new BMenuItem(B_TRANSLATE("Reset size"),
469 new BMessage(ZOOM_FACTOR_RESET), '0'));
470 fZoomTextOnlyMenuItem = new BMenuItem(B_TRANSLATE("Zoom text only"),
471 new BMessage(ZOOM_TEXT_ONLY));
472 fZoomTextOnlyMenuItem->SetMarked(fZoomTextOnly);
473 menu->AddItem(fZoomTextOnlyMenuItem);
474
475 menu->AddSeparatorItem();
476 fFullscreenItem = new BMenuItem(B_TRANSLATE("Full screen"),
477 new BMessage(TOGGLE_FULLSCREEN), B_RETURN);
478 menu->AddItem(fFullscreenItem);
479 menu->AddItem(new BMenuItem(B_TRANSLATE("Page source"),
480 new BMessage(SHOW_PAGE_SOURCE), 'U'));
481 mainMenu->AddItem(menu);
482
483 fHistoryMenu = new BMenu(B_TRANSLATE("History"));
484 fHistoryMenu->AddItem(fBackMenuItem = new BMenuItem(B_TRANSLATE("Back"),
485 new BMessage(GO_BACK), B_LEFT_ARROW));
486 fHistoryMenu->AddItem(fForwardMenuItem
487 = new BMenuItem(B_TRANSLATE("Forward"), new BMessage(GO_FORWARD),
488 B_RIGHT_ARROW));
489 fHistoryMenu->AddSeparatorItem();
490 fHistoryMenuFixedItemCount = fHistoryMenu->CountItems();
491 mainMenu->AddItem(fHistoryMenu);
492
493 BPath bookmarkPath;
494 entry_ref bookmarkRef;
495 if (_BookmarkPath(bookmarkPath) == B_OK
496 && get_ref_for_path(bookmarkPath.Path(), &bookmarkRef) == B_OK) {
497 BMenu* bookmarkMenu
498 = new BookmarkMenu(B_TRANSLATE("Bookmarks"), this, &bookmarkRef);
499 mainMenu->AddItem(bookmarkMenu);
500
501 BDirectory barDir(&bookmarkRef);
502 BEntry bookmarkBar(&barDir, "Bookmark bar");
503 entry_ref bookmarkBarRef;
504 // TODO we could also check if the folder is empty here.
505 if (bookmarkBar.Exists() && bookmarkBar.GetRef(&bookmarkBarRef)
506 == B_OK) {
507 fBookmarkBar = new BookmarkBar("Bookmarks", this, &bookmarkBarRef);
508 fBookmarkBarMenuItem->SetEnabled(true);
509 } else
510 fBookmarkBarMenuItem->SetEnabled(false);
511 } else
512 fBookmarkBarMenuItem->SetEnabled(false);
513
514 // Back, Forward, Stop & Home buttons
515 fBackButton = new BIconButton("Back", NULL, new BMessage(GO_BACK));
516 fBackButton->SetIcon(201);
517 fBackButton->TrimIcon();
518
519 fForwardButton = new BIconButton("Forward", NULL, new BMessage(GO_FORWARD));
520 fForwardButton->SetIcon(202);
521 fForwardButton->TrimIcon();
522
523 fStopButton = new BIconButton("Stop", NULL, new BMessage(STOP));
524 fStopButton->SetIcon(204);
525 fStopButton->TrimIcon();
526
527 fHomeButton = new BIconButton("Home", NULL, new BMessage(HOME));
528 fHomeButton->SetIcon(206);
529 fHomeButton->TrimIcon();
530 if (!fAppSettings->GetValue(kSettingsKeyShowHomeButton, true))
531 fHomeButton->Hide();
532
533 // URL input group
534 fURLInputGroup = new URLInputGroup(new BMessage(GOTO_URL));
535
536 // Status Bar
537 fStatusText = new BStringView("status", "");
538 fStatusText->SetAlignment(B_ALIGN_LEFT);
539 fStatusText->SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
540 fStatusText->SetExplicitMinSize(BSize(150, 12));
541 // Prevent the window from growing to fit a long status message...
542 BFont font(be_plain_font);
543 font.SetSize(ceilf(font.Size() * 0.8));
544 fStatusText->SetFont(&font, B_FONT_SIZE);
545
546 // Loading progress bar
547 fLoadingProgressBar = new BStatusBar("progress");
548 fLoadingProgressBar->SetMaxValue(100);
549 fLoadingProgressBar->Hide();
550 fLoadingProgressBar->SetBarHeight(12);
551
552 const float kInsetSpacing = 3;
553 const float kElementSpacing = 5;
554
555 // Find group
556 fFindCloseButton = new CloseButton(new BMessage(EDIT_HIDE_FIND_GROUP));
557 fFindTextControl = new BTextControl("find", B_TRANSLATE("Find:"), "", NULL);
558 fFindTextControl->SetModificationMessage(new BMessage(FIND_TEXT_CHANGED));
559 fFindPreviousButton = new BButton(B_TRANSLATE("Previous"),
560 new BMessage(EDIT_FIND_PREVIOUS));
561 fFindPreviousButton->SetToolTip(
562 B_TRANSLATE_COMMENT("Find previous occurrence of search terms",
563 "find bar previous button tooltip"));
564 fFindNextButton = new BButton(B_TRANSLATE("Next"),
565 new BMessage(EDIT_FIND_NEXT));
566 fFindNextButton->SetToolTip(
567 B_TRANSLATE_COMMENT("Find next occurrence of search terms",
568 "find bar next button tooltip"));
569 fFindCaseSensitiveCheckBox = new BCheckBox(B_TRANSLATE("Match case"));
570 BGroupLayout* findGroup = BLayoutBuilder::Group<>(B_VERTICAL, 0.0)
571 .Add(new BSeparatorView(B_HORIZONTAL, B_PLAIN_BORDER))
572 .Add(BGroupLayoutBuilder(B_HORIZONTAL, B_USE_SMALL_SPACING)
573 .Add(fFindCloseButton)
574 .Add(fFindTextControl)
575 .Add(fFindPreviousButton)
576 .Add(fFindNextButton)
577 .Add(fFindCaseSensitiveCheckBox)
578 .SetInsets(kInsetSpacing, kInsetSpacing,
579 kInsetSpacing, kInsetSpacing)
580 )
581 ;
582
583 // Navigation group
584 BGroupLayout* navigationGroup = BLayoutBuilder::Group<>(B_VERTICAL, 0.0)
585 .Add(BLayoutBuilder::Group<>(B_HORIZONTAL, kElementSpacing)
586 .Add(fBackButton)
587 .Add(fForwardButton)
588 .Add(fStopButton)
589 .Add(fHomeButton)
590 .Add(fURLInputGroup)
591 .SetInsets(kInsetSpacing, kInsetSpacing, kInsetSpacing,
592 kInsetSpacing)
593 )
594 .Add(new BSeparatorView(B_HORIZONTAL, B_PLAIN_BORDER))
595 ;
596
597 // Status bar group
598 BGroupLayout* statusGroup = BLayoutBuilder::Group<>(B_VERTICAL, 0.0)
599 .Add(new BSeparatorView(B_HORIZONTAL, B_PLAIN_BORDER))
600 .Add(BLayoutBuilder::Group<>(B_HORIZONTAL, kElementSpacing)
601 .Add(fStatusText)
602 .Add(fLoadingProgressBar, 0.2)
603 .AddStrut(12 - kElementSpacing)
604 .SetInsets(kInsetSpacing, 0, kInsetSpacing, 0)
605 )
606 ;
607
608 BitmapButton* toggleFullscreenButton = new BitmapButton(kWindowIconBits,
609 kWindowIconWidth, kWindowIconHeight, kWindowIconFormat,
610 new BMessage(TOGGLE_FULLSCREEN));
611 toggleFullscreenButton->SetBackgroundMode(BitmapButton::MENUBAR_BACKGROUND);
612
613 BGroupLayout* menuBarGroup = BLayoutBuilder::Group<>(B_HORIZONTAL, 0.0)
614 .Add(mainMenu)
615 .Add(toggleFullscreenButton, 0.0f)
616 ;
617
618 if (fAppSettings->GetValue(kSettingsShowBookmarkBar, true))
619 _ShowBookmarkBar(true);
620 else
621 _ShowBookmarkBar(false);
622
623 fSavePanel = new BFilePanel(B_SAVE_PANEL, new BMessenger(this), NULL, 0,
624 false);
625
626 // Layout
627 BGroupView* topView = new BGroupView(B_VERTICAL, 0.0);
628
629 #if !INTEGRATE_MENU_INTO_TAB_BAR
630 topView->AddChild(menuBarGroup);
631 #endif
632 topView->AddChild(fTabManager->TabGroup());
633 topView->AddChild(navigationGroup);
634 if (fBookmarkBar != NULL)
635 topView->AddChild(fBookmarkBar);
636 topView->AddChild(fTabManager->ContainerView());
637 topView->AddChild(findGroup);
638 topView->AddChild(statusGroup);
639
640 AddChild(topView);
641
642 fURLInputGroup->MakeFocus(true);
643
644 fMenuGroup = menuBarGroup;
645 fTabGroup = fTabManager->TabGroup()->GetLayout();
646 fNavigationGroup = navigationGroup;
647 fFindGroup = findGroup;
648 fStatusGroup = statusGroup;
649 fToggleFullscreenButton = layoutItemFor(toggleFullscreenButton);
650
651 fFindGroup->SetVisible(false);
652 fToggleFullscreenButton->SetVisible(false);
653
654 CreateNewTab(url, true, webView);
655 _ShowInterface(true);
656 _SetAutoHideInterfaceInFullscreen(fAppSettings->GetValue(
657 kSettingsKeyAutoHideInterfaceInFullscreenMode,
658 fAutoHideInterfaceInFullscreenMode));
659
660 AddShortcut('F', B_COMMAND_KEY | B_SHIFT_KEY,
661 new BMessage(EDIT_HIDE_FIND_GROUP));
662 // TODO: Should be a different shortcut, H is usually for Find selection.
663 AddShortcut('H', B_COMMAND_KEY, new BMessage(HOME));
664
665 // Add shortcuts to select a particular tab
666 for (int32 i = 1; i <= 9; i++) {
667 BMessage* selectTab = new BMessage(SELECT_TAB);
668 selectTab->AddInt32("tab index", i - 1);
669 char numStr[2];
670 snprintf(numStr, sizeof(numStr), "%d", (int) i);
671 AddShortcut(numStr[0], B_COMMAND_KEY, selectTab);
672 }
673
674 BKeymap keymap;
675 keymap.SetToCurrent();
676 BObjectList<const char> unmodified(3, true);
677 if (keymap.GetModifiedCharacters("+", B_SHIFT_KEY, 0, &unmodified)
678 == B_OK) {
679 int32 count = unmodified.CountItems();
680 for (int32 i = 0; i < count; i++) {
681 uint32 key = BUnicodeChar::FromUTF8(unmodified.ItemAt(i));
682 if (!HasShortcut(key, 0)) {
683 // Add semantic zoom in shortcut, bug #7428
684 AddShortcut(key, B_COMMAND_KEY,
685 new BMessage(ZOOM_FACTOR_INCREASE));
686 }
687 }
688 }
689 unmodified.MakeEmpty();
690
691 be_app->PostMessage(WINDOW_OPENED);
692 }
693
694
695 BrowserWindow::~BrowserWindow()
696 {
697 fAppSettings->RemoveListener(BMessenger(this));
698 delete fTabManager;
699 delete fPulseRunner;
700 delete fSavePanel;
701 }
702
703
704 void
705 BrowserWindow::DispatchMessage(BMessage* message, BHandler* target)
706 {
707 const char* bytes;
708 int32 modifierKeys;
709 if ((message->what == B_KEY_DOWN || message->what == B_UNMAPPED_KEY_DOWN)
710 && message->FindString("bytes", &bytes) == B_OK
711 && message->FindInt32("modifiers", &modifierKeys) == B_OK) {
712 if (bytes[0] == B_FUNCTION_KEY) {
713 // Some function key Firefox compatibility
714 int32 key;
715 if (message->FindInt32("key", &key) == B_OK) {
716 switch (key) {
717 case B_F5_KEY:
718 PostMessage(RELOAD);
719 break;
720
721 case B_F11_KEY:
722 PostMessage(TOGGLE_FULLSCREEN);
723 break;
724
725 default:
726 break;
727 }
728 }
729 } else if (target == fURLInputGroup->TextView()) {
730 // Handle B_RETURN in the URL text control. This is the easiest
731 // way to react *only* when the user presses the return key in the
732 // address bar, as opposed to trying to load whatever is in there
733 // when the text control just goes out of focus.
734 if (bytes[0] == B_RETURN) {
735 // Do it in such a way that the user sees the Go-button go down.
736 _InvokeButtonVisibly(fURLInputGroup->GoButton());
737 return;
738 } else if (bytes[0] == B_ESCAPE) {
739 // Replace edited text with the current URL.
740 fURLInputGroup->LockURLInput(false);
741 fURLInputGroup->SetText(CurrentWebView()->MainFrameURL());
742 }
743 } else if (target == fFindTextControl->TextView()) {
744 // Handle B_RETURN when the find text control has focus.
745 if (bytes[0] == B_RETURN) {
746 if ((modifierKeys & B_SHIFT_KEY) != 0)
747 _InvokeButtonVisibly(fFindPreviousButton);
748 else
749 _InvokeButtonVisibly(fFindNextButton);
750 return;
751 } else if (bytes[0] == B_ESCAPE) {
752 _InvokeButtonVisibly(fFindCloseButton);
753 return;
754 }
755 } else if (bytes[0] == B_ESCAPE && !fMenusRunning) {
756 if (modifierKeys == B_COMMAND_KEY)
757 _ShowInterface(true);
758 else {
759 // Default escape key behavior:
760 PostMessage(STOP);
761 return;
762 }
763 }
764 }
765
766 if (message->what == B_MOUSE_MOVED || message->what == B_MOUSE_DOWN
767 || message->what == B_MOUSE_UP) {
768 message->FindPoint("where", &fLastMousePos);
769 if (message->FindInt64("when", &fLastMouseMovedTime) != B_OK)
770 fLastMouseMovedTime = system_time();
771 _CheckAutoHideInterface();
772 }
773
774 if (message->what == B_MOUSE_WHEEL_CHANGED) {
775 BPoint where;
776 uint32 buttons;
777 CurrentWebView()->GetMouse(&where, &buttons, false);
778 // Only do this when the mouse is over the web view
779 if (CurrentWebView()->Bounds().Contains(where)) {
780 // Zoom and unzoom text on Command + mouse wheel.
781 // This could of course (and maybe should be) implemented in the
782 // WebView, but there would need to be a way for the WebView to
783 // know the setting of the fZoomTextOnly member here. Plus other
784 // clients of the API may not want this feature.
785 if ((modifiers() & B_COMMAND_KEY) != 0) {
786 float deltaY;
787 if (message->FindFloat("be:wheel_delta_y", &deltaY) == B_OK) {
788 if (deltaY < 0)
789 CurrentWebView()->IncreaseZoomFactor(fZoomTextOnly);
790 else
791 CurrentWebView()->DecreaseZoomFactor(fZoomTextOnly);
792
793 return;
794 }
795 }
796 } else {
797 // Also don't scroll up and down if the mouse is not over the
798 // web view
799 return;
800 }
801 }
802
803 BWebWindow::DispatchMessage(message, target);
804 }
805
806
807 void
808 BrowserWindow::MessageReceived(BMessage* message)
809 {
810 switch (message->what) {
811 case OPEN_LOCATION:
812 _ShowInterface(true);
813 if (fURLInputGroup->TextView()->IsFocus())
814 fURLInputGroup->TextView()->SelectAll();
815 else
816 fURLInputGroup->MakeFocus(true);
817 break;
818
819 case RELOAD:
820 CurrentWebView()->Reload();
821 break;
822
823 case SHOW_HIDE_BOOKMARK_BAR:
824 _ShowBookmarkBar(fBookmarkBar->IsHidden());
825 break;
826
827 case GOTO_URL:
828 {
829 BString url;
830 if (message->FindString("url", &url) != B_OK)
831 url = fURLInputGroup->Text();
832
833 _SetPageIcon(CurrentWebView(), NULL);
834 _SmartURLHandler(url);
835
836 break;
837 }
838
839 case SAVE_PAGE:
840 {
841 fSavePanel->SetSaveText(CurrentWebView()->MainFrameTitle());
842 fSavePanel->Show();
843 break;
844 }
845
846 case B_SAVE_REQUESTED:
847 {
848 entry_ref ref;
849 BString name;
850
851 if (message->FindRef("directory", &ref) == B_OK
852 && message->FindString("name", &name) == B_OK) {
853 BDirectory dir(&ref);
854 BFile output(&dir, name,
855 B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
856 CurrentWebView()->WebPage()->GetContentsAsMHTML(output);
857 }
858
859 break;
860 }
861
862 case GO_BACK:
863 CurrentWebView()->GoBack();
864 break;
865
866 case GO_FORWARD:
867 CurrentWebView()->GoForward();
868 break;
869
870 case STOP:
871 CurrentWebView()->StopLoading();
872 break;
873
874 case HOME:
875 CurrentWebView()->LoadURL(fStartPageURL);
876 break;
877
878 case CLEAR_HISTORY: {
879 BrowsingHistory* history = BrowsingHistory::DefaultInstance();
880 if (history->CountItems() == 0)
881 break;
882 BAlert* alert = new BAlert(B_TRANSLATE("Confirmation"),
883 B_TRANSLATE("Do you really want to "
884 "clear the browsing history?"), B_TRANSLATE("Clear"),
885 B_TRANSLATE("Cancel"));
886 alert->SetShortcut(1, B_ESCAPE);
887
888 if (alert->Go() == 0)
889 history->Clear();
890 break;
891 }
892
893 case CREATE_BOOKMARK:
894 _CreateBookmark();
895 break;
896
897 case SHOW_BOOKMARKS:
898 _ShowBookmarks();
899 break;
900
901 case B_REFS_RECEIVED:
902 {
903 // Currently the only source of these messages is the bookmarks
904 // menu.
905 // Filter refs into URLs, this also gets rid of refs for folders.
906 // For clicks on sub-folders in the bookmarks menu, we have Tracker
907 // open the corresponding folder.
908 entry_ref ref;
909 uint32 addedCount = 0;
910 for (int32 i = 0; message->FindRef("refs", i, &ref) == B_OK; i++) {
911 BEntry entry(&ref);
912 uint32 addedSubCount = 0;
913 if (entry.IsDirectory()) {
914 BDirectory directory(&entry);
915 _AddBookmarkURLsRecursively(directory, message,
916 addedSubCount);
917 } else {
918 BFile file(&ref, B_READ_ONLY);
919 BString url;
920 if (_ReadURLAttr(file, url)) {
921 message->AddString("url", url.String());
922 addedSubCount++;
923 }
924 }
925 if (addedSubCount == 0) {
926 // Don't know what to do with this entry, just pass it
927 // on to the system to handle. Note that this may result
928 // in us opening other supported files via the application
929 // mechanism.
930 be_roster->Launch(&ref);
931 }
932 addedCount += addedSubCount;
933 }
934 message->RemoveName("refs");
935 if (addedCount > 10) {
936 BString string(B_TRANSLATE_COMMENT("Do you want to open "
937 "%addedCount bookmarks all at once?", "Don't translate "
938 "variable %addedCount."));
939 string.ReplaceFirst("%addedCount", BString() << addedCount);
940
941 BAlert* alert = new BAlert(
942 B_TRANSLATE("Open bookmarks confirmation"),
943 string.String(), B_TRANSLATE("Cancel"),
944 B_TRANSLATE("Open all"));
945 alert->SetShortcut(0, B_ESCAPE);
946 if (alert->Go() == 0)
947 break;
948 }
949 message->AddPointer("window", this);
950 be_app->PostMessage(message);
951 break;
952 }
953
954 case B_SIMPLE_DATA:
955 {
956 // User possibly dropped files on this window.
957 // If there is more than one entry_ref, let the app handle it
958 // (open one new page per ref). If there is one ref, open it in
959 // this window.
960 type_code type;
961 int32 countFound;
962 if (message->GetInfo("refs", &type, &countFound) != B_OK
963 || type != B_REF_TYPE) {
964 break;
965 }
966 if (countFound > 1) {
967 message->what = B_REFS_RECEIVED;
968 be_app->PostMessage(message);
969 break;
970 }
971 entry_ref ref;
972 if (message->FindRef("refs", &ref) != B_OK)
973 break;
974 BEntry entry(&ref, true);
975 BPath path;
976 if (!entry.Exists() || entry.GetPath(&path) != B_OK)
977 break;
978
979 BUrl url(path);
980 CurrentWebView()->LoadURL(url);
981 break;
982 }
983
984 case ZOOM_FACTOR_INCREASE:
985 CurrentWebView()->IncreaseZoomFactor(fZoomTextOnly);
986 break;
987 case ZOOM_FACTOR_DECREASE:
988 CurrentWebView()->DecreaseZoomFactor(fZoomTextOnly);
989 break;
990 case ZOOM_FACTOR_RESET:
991 CurrentWebView()->ResetZoomFactor();
992 break;
993 case ZOOM_TEXT_ONLY:
994 fZoomTextOnly = !fZoomTextOnly;
995 fZoomTextOnlyMenuItem->SetMarked(fZoomTextOnly);
996 // TODO: Would be nice to have an instant update if the page is
997 // already zoomed.
998 break;
999
1000 case TOGGLE_FULLSCREEN:
1001 ToggleFullscreen();
1002 break;
1003
1004 case TOGGLE_AUTO_HIDE_INTERFACE_IN_FULLSCREEN:
1005 _SetAutoHideInterfaceInFullscreen(
1006 !fAutoHideInterfaceInFullscreenMode);
1007 break;
1008
1009 case CHECK_AUTO_HIDE_INTERFACE:
1010 _CheckAutoHideInterface();
1011 break;
1012
1013 case SHOW_PAGE_SOURCE:
1014 CurrentWebView()->WebPage()->SendPageSource();
1015 break;
1016 case B_PAGE_SOURCE_RESULT:
1017 _HandlePageSourceResult(message);
1018 break;
1019
1020 case EDIT_FIND_NEXT:
1021 CurrentWebView()->FindString(fFindTextControl->Text(), true,
1022 fFindCaseSensitiveCheckBox->Value());
1023 break;
1024 case FIND_TEXT_CHANGED:
1025 {
1026 bool findTextAvailable = strlen(fFindTextControl->Text()) > 0;
1027 fFindPreviousMenuItem->SetEnabled(findTextAvailable);
1028 fFindNextMenuItem->SetEnabled(findTextAvailable);
1029 break;
1030 }
1031 case EDIT_FIND_PREVIOUS:
1032 CurrentWebView()->FindString(fFindTextControl->Text(), false,
1033 fFindCaseSensitiveCheckBox->Value());
1034 break;
1035 case EDIT_SHOW_FIND_GROUP:
1036 if (!fFindGroup->IsVisible())
1037 fFindGroup->SetVisible(true);
1038 fFindTextControl->MakeFocus(true);
1039 break;
1040 case EDIT_HIDE_FIND_GROUP:
1041 if (fFindGroup->IsVisible()) {
1042 fFindGroup->SetVisible(false);
1043 if (CurrentWebView() != NULL)
1044 CurrentWebView()->MakeFocus(true);
1045 }
1046 break;
1047
1048 case B_CUT:
1049 case B_COPY:
1050 case B_PASTE:
1051 {
1052 BTextView* textView = dynamic_cast<BTextView*>(CurrentFocus());
1053 if (textView != NULL)
1054 textView->MessageReceived(message);
1055 else if (CurrentWebView() != NULL)
1056 CurrentWebView()->MessageReceived(message);
1057 break;
1058 }
1059
1060 case B_EDITING_CAPABILITIES_RESULT:
1061 {
1062 BWebView* webView;
1063 if (message->FindPointer("view",
1064 reinterpret_cast<void**>(&webView)) != B_OK
1065 || webView != CurrentWebView()) {
1066 break;
1067 }
1068 bool canCut;
1069 bool canCopy;
1070 bool canPaste;
1071 if (message->FindBool("can cut", &canCut) != B_OK)
1072 canCut = false;
1073 if (message->FindBool("can copy", &canCopy) != B_OK)
1074 canCopy = false;
1075 if (message->FindBool("can paste", &canPaste) != B_OK)
1076 canPaste = false;
1077 fCutMenuItem->SetEnabled(canCut);
1078 fCopyMenuItem->SetEnabled(canCopy);
1079 fPasteMenuItem->SetEnabled(canPaste);
1080 break;
1081 }
1082
1083 case SHOW_DOWNLOAD_WINDOW:
1084 case SHOW_SETTINGS_WINDOW:
1085 case SHOW_CONSOLE_WINDOW:
1086 case SHOW_COOKIE_WINDOW:
1087 message->AddUInt32("workspaces", Workspaces());
1088 be_app->PostMessage(message);
1089 break;
1090
1091 case CLOSE_TAB:
1092 if (fTabManager->CountTabs() > 1) {
1093 int32 index;
1094 if (message->FindInt32("tab index", &index) != B_OK)
1095 index = fTabManager->SelectedTabIndex();
1096 _ShutdownTab(index);
1097 _UpdateTabGroupVisibility();
1098 } else
1099 PostMessage(B_QUIT_REQUESTED);
1100 break;
1101
1102 case SELECT_TAB:
1103 {
1104 int32 index;
1105 if (message->FindInt32("tab index", &index) == B_OK
1106 && fTabManager->SelectedTabIndex() != index
1107 && fTabManager->CountTabs() > index) {
1108 fTabManager->SelectTab(index);
1109 }
1110
1111 break;
1112 }
1113
1114 case TAB_CHANGED:
1115 {
1116 // This message may be received also when the last tab closed,
1117 // i.e. with index == -1.
1118 int32 index;
1119 if (message->FindInt32("tab index", &index) != B_OK)
1120 index = -1;
1121 _TabChanged(index);
1122 break;
1123 }
1124
1125 case SETTINGS_VALUE_CHANGED:
1126 {
1127 BString name;
1128 if (message->FindString("name", &name) != B_OK)
1129 break;
1130 bool flag;
1131 BString string;
1132 uint32 value;
1133 if (name == kSettingsKeyShowTabsIfSinglePageOpen
1134 && message->FindBool("value", &flag) == B_OK) {
1135 if (fShowTabsIfSinglePageOpen != flag) {
1136 fShowTabsIfSinglePageOpen = flag;
1137 _UpdateTabGroupVisibility();
1138 }
1139 } else if (name == kSettingsKeyAutoHidePointer
1140 && message->FindBool("value", &flag) == B_OK) {
1141 fAutoHidePointer = flag;
1142 if (CurrentWebView())
1143 CurrentWebView()->SetAutoHidePointer(fAutoHidePointer);
1144 } else if (name == kSettingsKeyStartPageURL
1145 && message->FindString("value", &string) == B_OK) {
1146 fStartPageURL = string;
1147 } else if (name == kSettingsKeySearchPageURL
1148 && message->FindString("value", &string) == B_OK) {
1149 fSearchPageURL = string;
1150 } else if (name == kSettingsKeyNewWindowPolicy
1151 && message->FindUInt32("value", &value) == B_OK) {
1152 fNewWindowPolicy = value;
1153 } else if (name == kSettingsKeyNewTabPolicy
1154 && message->FindUInt32("value", &value) == B_OK) {
1155 fNewTabPolicy = value;
1156 } else if (name == kSettingsKeyAutoHideInterfaceInFullscreenMode
1157 && message->FindBool("value", &flag) == B_OK) {
1158 _SetAutoHideInterfaceInFullscreen(flag);
1159 } else if (name == kSettingsKeyShowHomeButton
1160 && message->FindBool("value", &flag) == B_OK) {
1161 if (flag)
1162 fHomeButton->Show();
1163 else
1164 fHomeButton->Hide();
1165 } else if (name == kSettingsShowBookmarkBar
1166 && message->FindBool("value", &flag) == B_OK) {
1167 _ShowBookmarkBar(flag);
1168 }
1169 break;
1170 }
1171 case ADD_CONSOLE_MESSAGE:
1172 be_app->PostMessage(message);
1173 BWebWindow::MessageReceived(message);
1174 break;
1175
1176 default:
1177 BWebWindow::MessageReceived(message);
1178 break;
1179 }
1180 }
1181
1182
1183 status_t
1184 BrowserWindow::Archive(BMessage* archive, bool deep) const
1185 {
1186 status_t ret = archive->AddRect("window frame", Frame());
1187
1188 for (int i = 0; i < fTabManager->CountTabs(); i++) {
1189 BWebView* view = dynamic_cast<BWebView*>(fTabManager->ViewForTab(i));
1190 if (view == NULL) {
1191 continue;
1192 }
1193
1194 if (ret == B_OK)
1195 ret = archive->AddString("tab", view->MainFrameURL());
1196 }
1197
1198 return ret;
1199 }
1200
1201
1202 bool
1203 BrowserWindow::QuitRequested()
1204 {
1205 // TODO: Check for modified form data and ask user for confirmation, etc.
1206
1207 BMessage message(WINDOW_CLOSED);
1208 Archive(&message);
1209
1210 // Iterate over all tabs to delete all BWebViews.
1211 // Do this here, so WebKit tear down happens earlier.
1212 SetCurrentWebView(NULL);
1213 while (fTabManager->CountTabs() > 0)
1214 _ShutdownTab(0);
1215
1216 message.AddRect("window frame", WindowFrame());
1217 be_app->PostMessage(&message);
1218 return true;
1219 }
1220
1221
1222 void
1223 BrowserWindow::MenusBeginning()
1224 {
1225 _UpdateHistoryMenu();
1226 _UpdateClipboardItems();
1227 fMenusRunning = true;
1228 }
1229
1230
1231 void
1232 BrowserWindow::MenusEnded()
1233 {
1234 fMenusRunning = false;
1235 }
1236
1237
1238 void
1239 BrowserWindow::ScreenChanged(BRect screenSize, color_space format)
1240 {
1241 if (fIsFullscreen)
1242 _ResizeToScreen();
1243 }
1244
1245
1246 void
1247 BrowserWindow::WorkspacesChanged(uint32 oldWorkspaces, uint32 newWorkspaces)
1248 {
1249 if (fIsFullscreen)
1250 _ResizeToScreen();
1251 }
1252
1253
1254 static bool
1255 viewIsChild(const BView* parent, const BView* view)
1256 {
1257 if (parent == view)
1258 return true;
1259
1260 int32 count = parent->CountChildren();
1261 for (int32 i = 0; i < count; i++) {
1262 BView* child = parent->ChildAt(i);
1263 if (viewIsChild(child, view))
1264 return true;
1265 }
1266 return false;
1267 }
1268
1269
1270 void
1271 BrowserWindow::SetCurrentWebView(BWebView* webView)
1272 {
1273 if (webView == CurrentWebView())
1274 return;
1275
1276 if (CurrentWebView() != NULL) {
1277 // Remember the currently focused view before switching tabs,
1278 // so that we can revert the focus when switching back to this tab
1279 // later.
1280 PageUserData* userData = static_cast<PageUserData*>(
1281 CurrentWebView()->GetUserData());
1282 if (userData == NULL) {
1283 userData = new PageUserData(CurrentFocus());
1284 CurrentWebView()->SetUserData(userData);
1285 }
1286 userData->SetFocusedView(CurrentFocus());
1287 userData->SetURLInputContents(fURLInputGroup->Text());
1288 int32 selectionStart;
1289 int32 selectionEnd;
1290 fURLInputGroup->TextView()->GetSelection(&selectionStart,
1291 &selectionEnd);
1292 userData->SetURLInputSelection(selectionStart, selectionEnd);
1293 }
1294
1295 BWebWindow::SetCurrentWebView(webView);
1296
1297 if (webView != NULL) {
1298 webView->SetAutoHidePointer(fAutoHidePointer);
1299
1300 _UpdateTitle(webView->MainFrameTitle());
1301
1302 // Restore the previous focus or focus the web view.
1303 PageUserData* userData = static_cast<PageUserData*>(
1304 webView->GetUserData());
1305 BView* focusedView = NULL;
1306 if (userData != NULL)
1307 focusedView = userData->FocusedView();
1308
1309 if (focusedView != NULL
1310 && viewIsChild(GetLayout()->View(), focusedView)) {
1311 focusedView->MakeFocus(true);
1312 } else
1313 webView->MakeFocus(true);
1314
1315 bool state = fURLInputGroup->IsURLInputLocked();
1316 fURLInputGroup->LockURLInput(false);
1317 // Unlock it so the following code can update the URL
1318
1319 if (userData != NULL) {
1320 fURLInputGroup->SetPageIcon(userData->PageIcon());
1321 if (userData->URLInputContents().Length())
1322 fURLInputGroup->SetText(userData->URLInputContents());
1323 else
1324 fURLInputGroup->SetText(webView->MainFrameURL());
1325 if (userData->URLInputSelectionStart() >= 0) {
1326 fURLInputGroup->TextView()->Select(
1327 userData->URLInputSelectionStart(),
1328 userData->URLInputSelectionEnd());
1329 }
1330 } else {
1331 fURLInputGroup->SetPageIcon(NULL);
1332 fURLInputGroup->SetText(webView->MainFrameURL());
1333 }
1334
1335 fURLInputGroup->LockURLInput(state);
1336 // Restore the state
1337
1338 // Trigger update of the interface to the new page, by requesting
1339 // to resend all notifications.
1340 webView->WebPage()->ResendNotifications();
1341 } else
1342 _UpdateTitle("");
1343 }
1344
1345
1346 bool
1347 BrowserWindow::IsBlankTab() const
1348 {
1349 if (CurrentWebView() == NULL)
1350 return false;
1351 BString requestedURL = CurrentWebView()->MainFrameRequestedURL();
1352 return requestedURL.Length() == 0
1353 || requestedURL == _NewTabURL(fTabManager->CountTabs() == 1);
1354 }
1355
1356
1357 void
1358 BrowserWindow::CreateNewTab(const BString& _url, bool select,
1359 BWebView* webView)
1360 {
1361 bool applyNewPagePolicy = webView == NULL;
1362 // Executed in app thread (new BWebPage needs to be created in app thread).
1363 if (webView == NULL)
1364 webView = new BWebView("web view", fContext);
1365
1366 bool isNewWindow = fTabManager->CountTabs() == 0;
1367
1368 fTabManager->AddTab(webView, B_TRANSLATE("New tab"));
1369
1370 BString url(_url);
1371 if (applyNewPagePolicy && url.Length() == 0)
1372 url = _NewTabURL(isNewWindow);
1373
1374 if (url.Length() > 0)
1375 webView->LoadURL(url.String());
1376
1377 if (select) {
1378 fTabManager->SelectTab(fTabManager->CountTabs() - 1);
1379 SetCurrentWebView(webView);
1380 webView->WebPage()->ResendNotifications();
1381 fURLInputGroup->SetPageIcon(NULL);
1382 fURLInputGroup->SetText(url.String());
1383 fURLInputGroup->MakeFocus(true);
1384 }
1385
1386 _ShowInterface(true);
1387 _UpdateTabGroupVisibility();
1388 }
1389
1390
1391 BRect
1392 BrowserWindow::WindowFrame() const
1393 {
1394 if (fIsFullscreen)
1395 return fNonFullscreenWindowFrame;
1396 else
1397 return Frame();
1398 }
1399
1400
1401 void
1402 BrowserWindow::ToggleFullscreen()
1403 {
1404 if (fIsFullscreen) {
1405 MoveTo(fNonFullscreenWindowFrame.LeftTop());
1406 ResizeTo(fNonFullscreenWindowFrame.Width(),
1407 fNonFullscreenWindowFrame.Height());
1408
1409 SetFlags(Flags() & ~(B_NOT_RESIZABLE | B_NOT_MOVABLE));
1410 SetLook(B_DOCUMENT_WINDOW_LOOK);
1411
1412 _ShowInterface(true);
1413 } else {
1414 fNonFullscreenWindowFrame = Frame();
1415 _ResizeToScreen();
1416
1417 SetFlags(Flags() | (B_NOT_RESIZABLE | B_NOT_MOVABLE));
1418 SetLook(B_TITLED_WINDOW_LOOK);
1419 }
1420 fIsFullscreen = !fIsFullscreen;
1421 fFullscreenItem->SetMarked(fIsFullscreen);
1422 fToggleFullscreenButton->SetVisible(fIsFullscreen);
1423 }
1424
1425
1426 // #pragma mark - Notification API
1427
1428
1429 void
1430 BrowserWindow::NavigationRequested(const BString& url, BWebView* view)
1431 {
1432 }
1433
1434
1435 void
1436 BrowserWindow::NewWindowRequested(const BString& url, bool primaryAction)
1437 {
1438 // Always open new windows in the application thread, since
1439 // creating a BWebView will try to grab the application lock.
1440 // But our own WebPage may already try to lock us from within
1441 // the application thread -> dead-lock. Thus we can't wait for
1442 // a reply here.
1443 BMessage message(NEW_TAB);
1444 message.AddPointer("window", this);
1445 message.AddString("url", url);
1446 message.AddBool("select", primaryAction);
1447 be_app->PostMessage(&message);
1448 }
1449
1450
1451 void
1452 BrowserWindow::NewPageCreated(BWebView* view, BRect windowFrame,
1453 bool modalDialog, bool resizable, bool activate)
1454 {
1455 if (windowFrame.IsValid()) {
1456 BrowserWindow* window = new BrowserWindow(windowFrame, fAppSettings,
1457 BString(), fContext, INTERFACE_ELEMENT_STATUS,
1458 view);
1459 window->Show();
1460 } else
1461 CreateNewTab(BString(), activate, view);
1462 }
1463
1464
1465 void
1466 BrowserWindow::CloseWindowRequested(BWebView* view)
1467 {
1468 int32 index = fTabManager->TabForView(view);
1469 if (index < 0) {
1470 // Tab is already gone.
1471 return;
1472 }
1473 BMessage message(CLOSE_TAB);
1474 message.AddInt32("tab index", index);
1475 PostMessage(&message, this);
1476 }
1477
1478
1479 void
1480 BrowserWindow::LoadNegotiating(const BString& url, BWebView* view)
1481 {
1482 if (view != CurrentWebView()) {
1483 // Update the userData contents instead so the user sees
1484 // the correct URL when they switch back to that tab.
1485 PageUserData* userData = static_cast<PageUserData*>(
1486 view->GetUserData());
1487 if (userData != NULL && userData->URLInputContents().Length() == 0) {
1488 userData->SetURLInputContents(url);
1489 }
1490 }
1491
1492 fURLInputGroup->SetText(url.String());
1493
1494 BString status(B_TRANSLATE("Requesting %url"));
1495 status.ReplaceFirst("%url", url);
1496 view->WebPage()->SetStatusMessage(status);
1497 }
1498
1499
1500 void
1501 BrowserWindow::LoadCommitted(const BString& url, BWebView* view)
1502 {
1503 if (view != CurrentWebView())
1504 return;
1505
1506 // This hook is invoked when the load is commited.
1507 fURLInputGroup->SetText(url.String());
1508
1509 BString status(B_TRANSLATE("Loading %url"));
1510 status.ReplaceFirst("%url", url);
1511 view->WebPage()->SetStatusMessage(status);
1512 }
1513
1514
1515 void
1516 BrowserWindow::LoadProgress(float progress, BWebView* view)
1517 {
1518 if (view != CurrentWebView())
1519 return;
1520
1521 if (progress < 100 && fLoadingProgressBar->IsHidden())
1522 _ShowProgressBar(true);
1523 else if (progress == 100 && !fLoadingProgressBar->IsHidden())
1524 _ShowProgressBar(false);
1525 fLoadingProgressBar->SetTo(progress);
1526 }
1527
1528
1529 void
1530 BrowserWindow::LoadFailed(const BString& url, BWebView* view)
1531 {
1532 if (view != CurrentWebView())
1533 return;
1534
1535 BString status(B_TRANSLATE_COMMENT("%url failed", "Loading URL failed. "
1536 "Don't translate variable %url."));
1537 status.ReplaceFirst("%url", url);
1538 view->WebPage()->SetStatusMessage(status);
1539 if (!fLoadingProgressBar->IsHidden())
1540 fLoadingProgressBar->Hide();
1541 }
1542
1543
1544 void
1545 BrowserWindow::LoadFinished(const BString& url, BWebView* view)
1546 {
1547 if (view != CurrentWebView())
1548 return;
1549
1550 fURLInputGroup->SetText(url.String());
1551
1552 BString status(B_TRANSLATE_COMMENT("%url finished", "Loading URL "
1553 "finished. Don't translate variable %url."));
1554 status.ReplaceFirst("%url", url);
1555 view->WebPage()->SetStatusMessage(status);
1556 if (!fLoadingProgressBar->IsHidden())
1557 fLoadingProgressBar->Hide();
1558
1559 NavigationCapabilitiesChanged(fBackButton->IsEnabled(),
1560 fForwardButton->IsEnabled(), false, view);
1561
1562 int32 tabIndex = fTabManager->TabForView(view);
1563 if (tabIndex > 0 && strcmp(B_TRANSLATE("New tab"),
1564 fTabManager->TabLabel(tabIndex)) == 0)
1565 fTabManager->SetTabLabel(tabIndex, url);
1566 }
1567
1568
1569 void
1570 BrowserWindow::MainDocumentError(const BString& failingURL,
1571 const BString& localizedDescription, BWebView* view)
1572 {
1573 // Make sure we show the page that contains the view.
1574 if (!_ShowPage(view))
1575 return;
1576
1577 // Try delegating the URL to an external app instead.
1578 int32 at = failingURL.FindFirst(":");
1579 if (at > 0) {
1580 BString proto;
1581 failingURL.CopyInto(proto, 0, at);
1582
1583 bool handled = false;
1584
1585 for (unsigned int i = 0; i < sizeof(kHandledProtocols) / sizeof(char*);
1586 i++) {
1587 handled = (proto == kHandledProtocols[i]);
1588 if (handled)
1589 break;
1590 }
1591
1592 if (!handled) {
1593 _SmartURLHandler(failingURL);
1594 return;
1595 }
1596 }
1597
1598 BWebWindow::MainDocumentError(failingURL, localizedDescription, view);
1599
1600 // TODO: Remove the failing URL from the BrowsingHistory!
1601 }
1602
1603
1604 void
1605 BrowserWindow::TitleChanged(const BString& title, BWebView* view)
1606 {
1607 int32 tabIndex = fTabManager->TabForView(view);
1608 if (tabIndex < 0)
1609 return;
1610
1611 fTabManager->SetTabLabel(tabIndex, title);
1612
1613 if (view != CurrentWebView())
1614 return;
1615
1616 _UpdateTitle(title);
1617 }
1618
1619
1620 void
1621 BrowserWindow::IconReceived(const BBitmap* icon, BWebView* view)
1622 {
1623 // The view may already be gone, since this notification arrives
1624 // asynchronously.
1625 if (!fTabManager->HasView(view))
1626 return;
1627
1628 _SetPageIcon(view, icon);
1629 }
1630
1631
1632 void
1633 BrowserWindow::ResizeRequested(float width, float height, BWebView* view)
1634 {
1635 if (view != CurrentWebView())
1636 return;
1637
1638 // Ignore request when there is more than one BWebView embedded.
1639 if (fTabManager->CountTabs() > 1)
1640 return;
1641
1642 // Make sure the new frame is not larger than the screen frame minus
1643 // window decorator border.
1644 BScreen screen(this);
1645 BRect screenFrame = screen.Frame();
1646 BRect decoratorFrame = DecoratorFrame();
1647 BRect frame = Frame();
1648
1649 screenFrame.left += decoratorFrame.left - frame.left;
1650 screenFrame.right += decoratorFrame.right - frame.right;
1651 screenFrame.top += decoratorFrame.top - frame.top;
1652 screenFrame.bottom += decoratorFrame.bottom - frame.bottom;
1653
1654 width = min_c(width, screen.Frame().Width());
1655 height = min_c(height, screen.Frame().Height());
1656
1657 frame.right = frame.left + width;
1658 frame.bottom = frame.top + height;
1659
1660 // frame is now not larger than screenFrame, but may still be partly outside
1661 if (!screenFrame.Contains(frame)) {
1662 if (frame.left < screenFrame.left)
1663 frame.OffsetBy(screenFrame.left - frame.left, 0);
1664 else if (frame.right > screenFrame.right)
1665 frame.OffsetBy(screenFrame.right - frame.right, 0);
1666 if (frame.top < screenFrame.top)
1667 frame.OffsetBy(screenFrame.top - frame.top, 0);
1668 else if (frame.bottom > screenFrame.bottom)
1669 frame.OffsetBy(screenFrame.bottom - frame.bottom, 0);
1670 }
1671
1672 MoveTo(frame.left, frame.top);
1673 ResizeTo(width, height);
1674 }
1675
1676
1677 void
1678 BrowserWindow::SetToolBarsVisible(bool flag, BWebView* view)
1679 {
1680 // TODO
1681 // TODO: Ignore request when there is more than one BWebView embedded!
1682 }
1683
1684
1685 void
1686 BrowserWindow::SetStatusBarVisible(bool flag, BWebView* view)
1687 {
1688 // TODO
1689 // TODO: Ignore request when there is more than one BWebView embedded!
1690 }
1691
1692
1693 void
1694 BrowserWindow::SetMenuBarVisible(bool flag, BWebView* view)
1695 {
1696 // TODO
1697 // TODO: Ignore request when there is more than one BWebView embedded!
1698 }
1699
1700
1701 void
1702 BrowserWindow::SetResizable(bool flag, BWebView* view)
1703 {
1704 // TODO: Ignore request when there is more than one BWebView embedded!
1705
1706 if (flag)
1707 SetFlags(Flags() & ~B_NOT_RESIZABLE);
1708 else
1709 SetFlags(Flags() | B_NOT_RESIZABLE);
1710 }
1711
1712
1713 void
1714 BrowserWindow::StatusChanged(const BString& statusText, BWebView* view)
1715 {
1716 if (view != CurrentWebView())
1717 return;
1718
1719 if (fStatusText)
1720 fStatusText->SetText(statusText.String());
1721 }
1722
1723
1724 void
1725 BrowserWindow::NavigationCapabilitiesChanged(bool canGoBackward,
1726 bool canGoForward, bool canStop, BWebView* view)
1727 {
1728 if (view != CurrentWebView())
1729 return;
1730
1731 fBackButton->SetEnabled(canGoBackward);
1732 fForwardButton->SetEnabled(canGoForward);
1733 fStopButton->SetEnabled(canStop);
1734
1735 fBackMenuItem->SetEnabled(canGoBackward);
1736 fForwardMenuItem->SetEnabled(canGoForward);
1737 }
1738
1739
1740 void
1741 BrowserWindow::UpdateGlobalHistory(const BString& url)
1742 {
1743 BrowsingHistory::DefaultInstance()->AddItem(BrowsingHistoryItem(url));
1744
1745 fURLInputGroup->SetText(CurrentWebView()->MainFrameURL());
1746 }
1747
1748
1749 bool
1750 BrowserWindow::AuthenticationChallenge(BString message, BString& inOutUser,
1751 BString& inOutPassword, bool& inOutRememberCredentials,
1752 uint32 failureCount, BWebView* view)
1753 {
1754 CredentialsStorage* persistentStorage
1755 = CredentialsStorage::PersistentInstance();
1756 CredentialsStorage* sessionStorage
1757 = CredentialsStorage::SessionInstance();
1758
1759 // TODO: Using the message as key here is not so smart.
1760 HashKeyString key(message);
1761
1762 if (failureCount == 0) {
1763 if (persistentStorage->Contains(key)) {
1764 Credentials credentials = persistentStorage->GetCredentials(key);
1765 inOutUser = credentials.Username();
1766 inOutPassword = credentials.Password();
1767 return true;
1768 } else if (sessionStorage->Contains(key)) {
1769 Credentials credentials = sessionStorage->GetCredentials(key);
1770 inOutUser = credentials.Username();
1771 inOutPassword = credentials.Password();
1772 return true;
1773 }
1774 }
1775 // Switch to the page for which this authentication is required.
1776 if (!_ShowPage(view))
1777 return false;
1778
1779 AuthenticationPanel* panel = new AuthenticationPanel(Frame());
1780 // Panel auto-destructs.
1781 bool success = panel->getAuthentication(message, inOutUser, inOutPassword,
1782 inOutRememberCredentials, failureCount > 0, inOutUser, inOutPassword,
1783 &inOutRememberCredentials);
1784 if (success) {
1785 Credentials credentials(inOutUser, inOutPassword);
1786 if (inOutRememberCredentials)
1787 persistentStorage->PutCredentials(key, credentials);
1788 else
1789 sessionStorage->PutCredentials(key, credentials);
1790 }
1791 return success;
1792 }
1793
1794
1795 // #pragma mark - private
1796
1797
1798 void
1799 BrowserWindow::_UpdateTitle(const BString& title)
1800 {
1801 BString windowTitle;
1802
1803 if (title.Length() > 0)
1804 windowTitle = title;
1805 else {
1806 BWebView* webView = CurrentWebView();
1807 if (webView != NULL) {
1808 BString url = webView->MainFrameURL();
1809 int32 leafPos = url.FindLast('/');
1810 url.Remove(0, leafPos + 1);
1811 windowTitle = url;
1812 }
1813 }
1814
1815 if (windowTitle.Length() > 0)
1816 windowTitle << " - ";
1817 windowTitle << kApplicationName;
1818 SetTitle(windowTitle.String());
1819 }
1820
1821
1822 void
1823 BrowserWindow::_UpdateTabGroupVisibility()
1824 {
1825 if (Lock()) {
1826 if (fInterfaceVisible)
1827 fTabGroup->SetVisible(_TabGroupShouldBeVisible());
1828 fTabManager->SetCloseButtonsAvailable(fTabManager->CountTabs() > 1);
1829 Unlock();
1830 }
1831 }
1832
1833
1834 bool
1835 BrowserWindow::_TabGroupShouldBeVisible() const
1836 {
1837 return (fShowTabsIfSinglePageOpen || fTabManager->CountTabs() > 1)
1838 && (fVisibleInterfaceElements & INTERFACE_ELEMENT_TABS) != 0;
1839 }
1840
1841
1842 void
1843 BrowserWindow::_ShutdownTab(int32 index)
1844 {
1845 BView* view = fTabManager->RemoveTab(index);
1846 BWebView* webView = dynamic_cast<BWebView*>(view);
1847 if (webView == CurrentWebView())
1848 SetCurrentWebView(NULL);
1849 if (webView != NULL)
1850 webView->Shutdown();
1851 else
1852 delete view;
1853 }
1854
1855
1856 void
1857 BrowserWindow::_TabChanged(int32 index)
1858 {
1859 SetCurrentWebView(dynamic_cast<BWebView*>(fTabManager->ViewForTab(index)));
1860 }
1861
1862
1863 status_t
1864 BrowserWindow::_BookmarkPath(BPath& path) const
1865 {
1866 status_t ret = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
1867 if (ret != B_OK)
1868 return ret;
1869
1870 ret = path.Append(kApplicationName);
1871 if (ret != B_OK)
1872 return ret;
1873
1874 ret = path.Append("Bookmarks");
1875 if (ret != B_OK)
1876 return ret;
1877
1878 return create_directory(path.Path(), 0777);
1879 }
1880
1881
1882 void
1883 BrowserWindow::_CreateBookmark()
1884 {
1885 BPath path;
1886 status_t status = _BookmarkPath(path);
1887 if (status != B_OK) {
1888 BString message(B_TRANSLATE_COMMENT("There was an error retrieving "
1889 "the bookmark folder.\n\nError: %error", "Don't translate the "
1890 "variable %error"));
1891 message.ReplaceFirst("%error", strerror(status));
1892 BAlert* alert = new BAlert(B_TRANSLATE("Bookmark error"),
1893 message.String(), B_TRANSLATE("OK"), NULL, NULL,
1894 B_WIDTH_AS_USUAL, B_STOP_ALERT);
1895 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
1896 alert->Go();
1897 return;
1898 }
1899 BWebView* webView = CurrentWebView();
1900 BString url(webView->MainFrameURL());
1901 // Create a bookmark file
1902 BFile bookmarkFile;
1903 BString bookmarkName(webView->MainFrameTitle());
1904 if (bookmarkName.Length() == 0) {
1905 bookmarkName = url;
1906 int32 leafPos = bookmarkName.FindLast('/');
1907 if (leafPos >= 0)
1908 bookmarkName.Remove(0, leafPos + 1);
1909 }
1910 // Make sure the bookmark title does not contain chars that are not
1911 // allowed in file names, and is within allowed name length.
1912 bookmarkName.ReplaceAll('/', '-');
1913 bookmarkName.Truncate(B_FILE_NAME_LENGTH - 1);
1914
1915 // Check that the bookmark exists nowhere in the bookmark hierarchy,
1916 // though the intended file name must match, we don't search the stored
1917 // URLs, only for matching file names.
1918 BDirectory directory(path.Path());
1919 if (status == B_OK && _CheckBookmarkExists(directory, bookmarkName, url)) {
1920 BString message(B_TRANSLATE_COMMENT("A bookmark for this page "
1921 "(%bookmarkName) already exists.", "Don't translate variable "
1922 "%bookmarkName"));
1923 message.ReplaceFirst("%bookmarkName", bookmarkName);
1924 BAlert* alert = new BAlert(B_TRANSLATE("Bookmark info"),
1925 message.String(), B_TRANSLATE("OK"));
1926 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
1927 alert->Go();
1928 return;
1929 }
1930
1931 BPath entryPath(path);
1932 status = entryPath.Append(bookmarkName);
1933 BEntry entry;
1934 if (status == B_OK)
1935 status = entry.SetTo(entryPath.Path(), true);
1936 if (status == B_OK) {
1937 int32 tries = 1;
1938 while (entry.Exists()) {
1939 // Find a unique name for the bookmark, there may still be a
1940 // file in the way that stores a different URL.
1941 bookmarkName = webView->MainFrameTitle();
1942 bookmarkName << " " << tries++;
1943 entryPath = path;
1944 status = entryPath.Append(bookmarkName);
1945 if (status == B_OK)
1946 status = entry.SetTo(entryPath.Path(), true);
1947 if (status != B_OK)
1948 break;
1949 }
1950 }
1951 if (status == B_OK) {
1952 status = bookmarkFile.SetTo(&entry,
1953 B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
1954 }
1955
1956 // Write bookmark meta data
1957 if (status == B_OK)
1958 status = bookmarkFile.WriteAttrString("META:url", &url);
1959 if (status == B_OK) {
1960 BString title = webView->MainFrameTitle();
1961 bookmarkFile.WriteAttrString("META:title", &title);
1962 }
1963
1964 BNodeInfo nodeInfo(&bookmarkFile);
1965 if (status == B_OK) {
1966 status = nodeInfo.SetType("application/x-vnd.Be-bookmark");
1967 if (status == B_OK) {
1968 PageUserData* userData = static_cast<PageUserData*>(
1969 webView->GetUserData());
1970 if (userData != NULL && userData->PageIcon() != NULL) {
1971 BBitmap miniIcon(BRect(0, 0, 15, 15), B_BITMAP_NO_SERVER_LINK,
1972 B_CMAP8);
1973 status_t ret = miniIcon.ImportBits(userData->PageIcon());
1974 if (ret == B_OK)
1975 ret = nodeInfo.SetIcon(&miniIcon, B_MINI_ICON);
1976 if (ret != B_OK) {
1977 fprintf(stderr, "Failed to store mini icon for bookmark: "
1978 "%s\n", strerror(ret));
1979 }
1980 BBitmap largeIcon(BRect(0, 0, 31, 31), B_BITMAP_NO_SERVER_LINK,
1981 B_CMAP8);
1982 // TODO: Store 32x32 favicon which is often provided by sites.
1983 const uint8* src = (const uint8*)miniIcon.Bits();
1984 uint32 srcBPR = miniIcon.BytesPerRow();
1985 uint8* dst = (uint8*)largeIcon.Bits();
1986 uint32 dstBPR = largeIcon.BytesPerRow();
1987 for (uint32 y = 0; y < 16; y++) {
1988 const uint8* s = src;
1989 uint8* d = dst;
1990 for (uint32 x = 0; x < 16; x++) {
1991 *d++ = *s;
1992 *d++ = *s++;
1993 }
1994 dst += dstBPR;
1995 s = src;
1996 for (uint32 x = 0; x < 16; x++) {
1997 *d++ = *s;
1998 *d++ = *s++;
1999 }
2000 dst += dstBPR;
2001 src += srcBPR;
2002 }
2003 if (ret == B_OK)
2004 ret = nodeInfo.SetIcon(&largeIcon, B_LARGE_ICON);
2005 if (ret != B_OK) {
2006 fprintf(stderr, "Failed to store large icon for bookmark: "
2007 "%s\n", strerror(ret));
2008 }
2009 }
2010 }
2011 }
2012
2013 if (status != B_OK) {
2014 BString message(B_TRANSLATE_COMMENT("There was an error creating the "
2015 "bookmark file.\n\nError: %error", "Don't translate variable "
2016 "%error"));
2017 message.ReplaceFirst("%error", strerror(status));
2018 BAlert* alert = new BAlert(B_TRANSLATE("Bookmark error"),
2019 message.String(), B_TRANSLATE("OK"), NULL, NULL,
2020 B_WIDTH_AS_USUAL, B_STOP_ALERT);
2021 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
2022 alert->Go();
2023 return;
2024 }
2025 }
2026
2027
2028 void
2029 BrowserWindow::_ShowBookmarks()
2030 {
2031 BPath path;
2032 entry_ref ref;
2033 status_t status = _BookmarkPath(path);
2034 if (status == B_OK)
2035 status = get_ref_for_path(path.Path(), &ref);
2036 if (status == B_OK)
2037 status = be_roster->Launch(&ref);
2038
2039 if (status != B_OK && status != B_ALREADY_RUNNING) {
2040 BString message(B_TRANSLATE_COMMENT("There was an error trying to "
2041 "show the Bookmarks folder.\n\nError: %error",
2042 "Don't translate variable %error"));
2043 message.ReplaceFirst("%error", strerror(status));
2044 BAlert* alert = new BAlert(B_TRANSLATE("Bookmark error"),
2045 message.String(), B_TRANSLATE("OK"), NULL, NULL,
2046 B_WIDTH_AS_USUAL, B_STOP_ALERT);
2047 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
2048 alert->Go();
2049 return;
2050 }
2051 }
2052
2053
2054 bool BrowserWindow::_CheckBookmarkExists(BDirectory& directory,
2055 const BString& bookmarkName, const BString& url) const
2056 {
2057 BEntry entry;
2058 while (directory.GetNextEntry(&entry) == B_OK) {
2059 if (entry.IsDirectory()) {
2060 BDirectory subBirectory(&entry);
2061 // At least preserve the entry file handle when recursing into
2062 // sub-folders... eventually we will run out, though, with very
2063 // deep hierarchy.
2064 entry.Unset();
2065 if (_CheckBookmarkExists(subBirectory, bookmarkName, url))
2066 return true;
2067 } else {
2068 char entryName[B_FILE_NAME_LENGTH];
2069 if (entry.GetName(entryName) != B_OK || bookmarkName != entryName)
2070 continue;
2071 BString storedURL;
2072 BFile file(&entry, B_READ_ONLY);
2073 if (_ReadURLAttr(file, storedURL)) {
2074 // Just bail if the bookmark already exists
2075 if (storedURL == url)
2076 return true;
2077 }
2078 }
2079 }
2080 return false;
2081 }
2082
2083
2084 bool
2085 BrowserWindow::_ReadURLAttr(BFile& bookmarkFile, BString& url) const
2086 {
2087 return bookmarkFile.InitCheck() == B_OK
2088 && bookmarkFile.ReadAttrString("META:url", &url) == B_OK;
2089 }
2090
2091
2092 void
2093 BrowserWindow::_AddBookmarkURLsRecursively(BDirectory& directory,
2094 BMessage* message, uint32& addedCount) const
2095 {
2096 BEntry entry;
2097 while (directory.GetNextEntry(&entry) == B_OK) {
2098 if (entry.IsDirectory()) {
2099 BDirectory subBirectory(&entry);
2100 // At least preserve the entry file handle when recursing into
2101 // sub-folders... eventually we will run out, though, with very
2102 // deep hierarchy.
2103 entry.Unset();
2104 _AddBookmarkURLsRecursively(subBirectory, message, addedCount);
2105 } else {
2106 BString storedURL;
2107 BFile file(&entry, B_READ_ONLY);
2108 if (_ReadURLAttr(file, storedURL)) {
2109 message->AddString("url", storedURL.String());
2110 addedCount++;
2111 }
2112 }
2113 }
2114 }
2115
2116
2117 void
2118 BrowserWindow::_SetPageIcon(BWebView* view, const BBitmap* icon)
2119 {
2120 PageUserData* userData = static_cast<PageUserData*>(view->GetUserData());
2121 if (userData == NULL) {
2122 userData = new(std::nothrow) PageUserData(NULL);
2123 if (userData == NULL)
2124 return;
2125 view->SetUserData(userData);
2126 }
2127 // The PageUserData makes a copy of the icon, which we pass on to
2128 // the TabManager for display in the respective tab.
2129 userData->SetPageIcon(icon);
2130 fTabManager->SetTabIcon(view, userData->PageIcon());
2131 if (view == CurrentWebView())
2132 fURLInputGroup->SetPageIcon(icon);
2133 }
2134
2135
2136 static void
2137 addItemToMenuOrSubmenu(BMenu* menu, BMenuItem* newItem)
2138 {
2139 BString baseURLLabel = baseURL(BString(newItem->Label()));
2140 for (int32 i = menu->CountItems() - 1; i >= 0; i--) {
2141 BMenuItem* item = menu->ItemAt(i);
2142 BString label = item->Label();
2143 if (label.FindFirst(baseURLLabel) >= 0) {
2144 if (item->Submenu()) {
2145 // Submenu was already added in previous iteration.
2146 item->Submenu()->AddItem(newItem);
2147 return;
2148 } else {
2149 menu->RemoveItem(item);
2150 BMenu* subMenu = new BMenu(baseURLLabel.String());
2151 subMenu->AddItem(item);
2152 subMenu->AddItem(newItem);
2153 // Add common submenu for this base URL, clickable.
2154 BMessage* message = new BMessage(GOTO_URL);
2155 message->AddString("url", baseURLLabel.String());
2156 menu->AddItem(new BMenuItem(subMenu, message), i);
2157 return;
2158 }
2159 }
2160 }
2161 menu->AddItem(newItem);
2162 }
2163
2164
2165 static void
2166 addOrDeleteMenu(BMenu* menu, BMenu* toMenu)
2167 {
2168 if (menu->CountItems() > 0)
2169 toMenu->AddItem(menu);
2170 else
2171 delete menu;
2172 }
2173
2174
2175 void
2176 BrowserWindow::_UpdateHistoryMenu()
2177 {
2178 BMenuItem* menuItem;
2179 while ((menuItem = fHistoryMenu->RemoveItem(fHistoryMenuFixedItemCount)))
2180 delete menuItem;
2181
2182 BrowsingHistory* history = BrowsingHistory::DefaultInstance();
2183 if (!history->Lock())
2184 return;
2185
2186 int32 count = history->CountItems();
2187 BMenuItem* clearHistoryItem = new BMenuItem(B_TRANSLATE("Clear history"),
2188 new BMessage(CLEAR_HISTORY));
2189 clearHistoryItem->SetEnabled(count > 0);
2190 fHistoryMenu->AddItem(clearHistoryItem);
2191 if (count == 0) {
2192 history->Unlock();
2193 return;
2194 }
2195 fHistoryMenu->AddSeparatorItem();
2196
2197 BDateTime todayStart = BDateTime::CurrentDateTime(B_LOCAL_TIME);
2198 todayStart.SetTime(BTime(0, 0, 0));
2199
2200 BDateTime oneDayAgoStart = todayStart;
2201 oneDayAgoStart.Date().AddDays(-1);
2202
2203 BDateTime twoDaysAgoStart = oneDayAgoStart;
2204 twoDaysAgoStart.Date().AddDays(-1);
2205
2206 BDateTime threeDaysAgoStart = twoDaysAgoStart;
2207 threeDaysAgoStart.Date().AddDays(-1);
2208
2209 BDateTime fourDaysAgoStart = threeDaysAgoStart;
2210 fourDaysAgoStart.Date().AddDays(-1);
2211
2212 BDateTime fiveDaysAgoStart = fourDaysAgoStart;
2213 fiveDaysAgoStart.Date().AddDays(-1);
2214
2215 BMenu* todayMenu = new BMenu(B_TRANSLATE("Today"));
2216 BMenu* yesterdayMenu = new BMenu(B_TRANSLATE("Yesterday"));
2217 BMenu* twoDaysAgoMenu = new BMenu(
2218 twoDaysAgoStart.Date().LongDayName().String());
2219 BMenu* threeDaysAgoMenu = new BMenu(
2220 threeDaysAgoStart.Date().LongDayName().String());
2221 BMenu* fourDaysAgoMenu = new BMenu(
2222 fourDaysAgoStart.Date().LongDayName().String());
2223 BMenu* fiveDaysAgoMenu = new BMenu(
2224 fiveDaysAgoStart.Date().LongDayName().String());
2225 BMenu* earlierMenu = new BMenu(B_TRANSLATE("Earlier"));
2226
2227 for (int32 i = 0; i < count; i++) {
2228 BrowsingHistoryItem historyItem = history->HistoryItemAt(i);
2229 BMessage* message = new BMessage(GOTO_URL);
2230 message->AddString("url", historyItem.URL().String());
2231
2232 BString truncatedUrl(historyItem.URL());
2233 be_plain_font->TruncateString(&truncatedUrl, B_TRUNCATE_END, 480);
2234 menuItem = new BMenuItem(truncatedUrl, message);
2235
2236 if (historyItem.DateTime() < fiveDaysAgoStart)
2237 addItemToMenuOrSubmenu(earlierMenu, menuItem);
2238 else if (historyItem.DateTime() < fourDaysAgoStart)
2239 addItemToMenuOrSubmenu(fiveDaysAgoMenu, menuItem);
2240 else if (historyItem.DateTime() < threeDaysAgoStart)
2241 addItemToMenuOrSubmenu(fourDaysAgoMenu, menuItem);
2242 else if (historyItem.DateTime() < twoDaysAgoStart)
2243 addItemToMenuOrSubmenu(threeDaysAgoMenu, menuItem);
2244 else if (historyItem.DateTime() < oneDayAgoStart)
2245 addItemToMenuOrSubmenu(twoDaysAgoMenu, menuItem);
2246 else if (historyItem.DateTime() < todayStart)
2247 addItemToMenuOrSubmenu(yesterdayMenu, menuItem);
2248 else
2249 addItemToMenuOrSubmenu(todayMenu, menuItem);
2250 }
2251 history->Unlock();
2252
2253 addOrDeleteMenu(todayMenu, fHistoryMenu);
2254 addOrDeleteMenu(yesterdayMenu, fHistoryMenu);
2255 addOrDeleteMenu(twoDaysAgoMenu, fHistoryMenu);
2256 addOrDeleteMenu(threeDaysAgoMenu, fHistoryMenu);
2257 addOrDeleteMenu(fourDaysAgoMenu, fHistoryMenu);
2258 addOrDeleteMenu(fiveDaysAgoMenu, fHistoryMenu);
2259 addOrDeleteMenu(earlierMenu, fHistoryMenu);
2260 }
2261
2262
2263 void
2264 BrowserWindow::_UpdateClipboardItems()
2265 {
2266 BTextView* focusTextView = dynamic_cast<BTextView*>(CurrentFocus());
2267 if (focusTextView != NULL) {
2268 int32 selectionStart;
2269 int32 selectionEnd;
2270 focusTextView->GetSelection(&selectionStart, &selectionEnd);
2271 bool hasSelection = selectionStart < selectionEnd;
2272 bool canPaste = false;
2273 // A BTextView has the focus.
2274 if (be_clipboard->Lock()) {
2275 BMessage* data = be_clipboard->Data();
2276 if (data != NULL)
2277 canPaste = data->HasData("text/plain", B_MIME_TYPE);
2278 be_clipboard->Unlock();
2279 }
2280 fCutMenuItem->SetEnabled(hasSelection);
2281 fCopyMenuItem->SetEnabled(hasSelection);
2282 fPasteMenuItem->SetEnabled(canPaste);
2283 } else if (CurrentWebView() != NULL) {
2284 // Trigger update of the clipboard items, even if the
2285 // BWebView doesn't have focus, we'll dispatch these message
2286 // there anyway. This works so fast that the user can never see
2287 // the wrong enabled state when the menu opens until the result
2288 // message arrives. The initial state needs to be enabled, since
2289 // standard shortcut handling is always wrapped inside MenusBeginning()
2290 // and MenusEnded(), and since we update items asynchronously, we need
2291 // to have them enabled to begin with.
2292 fCutMenuItem->SetEnabled(true);
2293 fCopyMenuItem->SetEnabled(true);
2294 fPasteMenuItem->SetEnabled(true);
2295
2296 CurrentWebView()->WebPage()->SendEditingCapabilities();
2297 }
2298 }
2299
2300
2301 bool
2302 BrowserWindow::_ShowPage(BWebView* view)
2303 {
2304 if (view != CurrentWebView()) {
2305 int32 tabIndex = fTabManager->TabForView(view);
2306 if (tabIndex < 0) {
2307 // Page seems to be gone already?
2308 return false;
2309 }
2310 fTabManager->SelectTab(tabIndex);
2311 _TabChanged(tabIndex);
2312 UpdateIfNeeded();
2313 }
2314 return true;
2315 }
2316
2317
2318 void
2319 BrowserWindow::_ResizeToScreen()
2320 {
2321 BScreen screen(this);
2322 MoveTo(0, 0);
2323 ResizeTo(screen.Frame().Width(), screen.Frame().Height());
2324 }
2325
2326
2327 void
2328 BrowserWindow::_SetAutoHideInterfaceInFullscreen(bool doIt)
2329 {
2330 if (fAutoHideInterfaceInFullscreenMode == doIt)
2331 return;
2332
2333 fAutoHideInterfaceInFullscreenMode = doIt;
2334 if (fAppSettings->GetValue(kSettingsKeyAutoHideInterfaceInFullscreenMode,
2335 doIt) != doIt) {
2336 fAppSettings->SetValue(kSettingsKeyAutoHideInterfaceInFullscreenMode,
2337 doIt);
2338 }
2339
2340 if (fAutoHideInterfaceInFullscreenMode) {
2341 BMessage message(CHECK_AUTO_HIDE_INTERFACE);
2342 fPulseRunner = new BMessageRunner(BMessenger(this), &message, 300000);
2343 } else {
2344 delete fPulseRunner;
2345 fPulseRunner = NULL;
2346 _ShowInterface(true);
2347 }
2348 }
2349
2350
2351 void
2352 BrowserWindow::_CheckAutoHideInterface()
2353 {
2354 if (!fIsFullscreen || !fAutoHideInterfaceInFullscreenMode
2355 || (CurrentWebView() != NULL && !CurrentWebView()->IsFocus())) {
2356 return;
2357 }
2358
2359 if (fLastMousePos.y == 0)
2360 _ShowInterface(true);
2361 else if (fNavigationGroup->IsVisible()
2362 && fLastMousePos.y > fNavigationGroup->Frame().bottom
2363 && system_time() - fLastMouseMovedTime > 1000000) {
2364 // NOTE: Do not re-use navigationGroupBottom in the above
2365 // check, since we only want to hide the interface when it is visible.
2366 _ShowInterface(false);
2367 }
2368 }
2369
2370
2371 void
2372 BrowserWindow::_ShowInterface(bool show)
2373 {
2374 if (fInterfaceVisible == show)
2375 return;
2376
2377 fInterfaceVisible = show;
2378
2379 if (show) {
2380 #if !INTEGRATE_MENU_INTO_TAB_BAR
2381 fMenuGroup->SetVisible(
2382 (fVisibleInterfaceElements & INTERFACE_ELEMENT_MENU) != 0);
2383 #endif
2384 fTabGroup->SetVisible(_TabGroupShouldBeVisible());
2385 fNavigationGroup->SetVisible(
2386 (fVisibleInterfaceElements & INTERFACE_ELEMENT_NAVIGATION) != 0);
2387 fStatusGroup->SetVisible(
2388 (fVisibleInterfaceElements & INTERFACE_ELEMENT_STATUS) != 0);
2389 } else {
2390 fMenuGroup->SetVisible(false);
2391 fTabGroup->SetVisible(false);
2392 fNavigationGroup->SetVisible(false);
2393 fStatusGroup->SetVisible(false);
2394 }
2395 // TODO: Setting the group visible seems to unhide the status bar.
2396 // Fix in Haiku?
2397 while (!fLoadingProgressBar->IsHidden())
2398 fLoadingProgressBar->Hide();
2399 }
2400
2401
2402 void
2403 BrowserWindow::_ShowProgressBar(bool show)
2404 {
2405 if (show) {
2406 if (!fStatusGroup->IsVisible() && (fVisibleInterfaceElements
2407 & INTERFACE_ELEMENT_STATUS) != 0)
2408 fStatusGroup->SetVisible(true);
2409 fLoadingProgressBar->Show();
2410 } else {
2411 if (!fInterfaceVisible)
2412 fStatusGroup->SetVisible(false);
2413 // TODO: This is also used in _ShowInterface. Without it the status bar
2414 // doesn't always hide again. It may be an Interface Kit bug.
2415 while (!fLoadingProgressBar->IsHidden())
2416 fLoadingProgressBar->Hide();
2417 }
2418 }
2419
2420
2421 void
2422 BrowserWindow::_InvokeButtonVisibly(BButton* button)
2423 {
2424 button->SetValue(B_CONTROL_ON);
2425 UpdateIfNeeded();
2426 button->Invoke();
2427 snooze(1000);
2428 button->SetValue(B_CONTROL_OFF);
2429 }
2430
2431
2432 BString
2433 BrowserWindow::_NewTabURL(bool isNewWindow) const
2434 {
2435 BString url;
2436 uint32 policy = isNewWindow ? fNewWindowPolicy : fNewTabPolicy;
2437 // Implement new page policy
2438 switch (policy) {
2439 case OpenStartPage:
2440 url = fStartPageURL;
2441 break;
2442 case OpenSearchPage:
2443 url.SetTo(fSearchPageURL);
2444 url.ReplaceAll("%s", "");
2445 break;
2446 case CloneCurrentPage:
2447 if (CurrentWebView() != NULL)
2448 url = CurrentWebView()->MainFrameURL();
2449 break;
2450 case OpenBlankPage:
2451 default:
2452 break;
2453 }
2454 return url;
2455 }
2456
2457
2458 BString
2459 BrowserWindow::_EncodeURIComponent(const BString& search)
2460 {
2461 // We have to take care of some of the escaping before we hand over the
2462 // search string to WebKit, if we want queries like "4+3" to not be
2463 // searched as "4 3".
2464 const BString escCharList = " $&`:<>[]{}\"+#%@/;=?\\^|~\',";
2465 BString result = search;
2466 char hexcode[4];
2467
2468 for (int32 i = 0; i < result.Length(); i++) {
2469 if (escCharList.FindFirst(result[i]) != B_ERROR) {
2470 sprintf(hexcode, "%02X", (unsigned int)result[i]);
2471 result.SetByteAt(i, '%');
2472 result.Insert(hexcode, i + 1);
2473 i += 2;
2474 }
2475 }
2476
2477 return result;
2478 }
2479
2480
2481 void
2482 BrowserWindow::_VisitURL(const BString& url)
2483 {
2484 // fURLInputGroup->TextView()->SetText(url);
2485 CurrentWebView()->LoadURL(url.String());
2486 }
2487
2488
2489 void
2490 BrowserWindow::_VisitSearchEngine(const BString& search)
2491 {
2492 BString engine(fSearchPageURL);
2493 engine.ReplaceAll("%s", _EncodeURIComponent(search).String());
2494
2495 _VisitURL(engine);
2496 }
2497
2498
2499 inline bool
2500 BrowserWindow::_IsValidDomainChar(char ch)
2501 {
2502 // TODO: Currenlty, only a whitespace character breaks a domain name. It
2503 // might be a good idea (or a bad one) to make character filtering based on
2504 // the IDNA 2008 standard.
2505
2506 return ch != ' ';
2507 }
2508
2509
2510 /*! \brief "smart" parser for user-entered URLs
2511
2512 We try to be flexible in what we accept as a valid URL. The protocol may
2513 be missing, or something we can't handle (in that case we run the matching
2514 app). If all attempts to make sense of the input fail, we make a search
2515 engine query for it.
2516 */
2517 void
2518 BrowserWindow::_SmartURLHandler(const BString& url)
2519 {
2520 // First test if the URL has a protocol field
2521 int32 at = url.FindFirst(":");
2522
2523 if (at != B_ERROR) {
2524 // There is a protocol, let's see if we can handle it
2525 BString proto;
2526 url.CopyInto(proto, 0, at);
2527
2528 bool handled = false;
2529
2530 // First try the built-in supported ones
2531 for (unsigned int i = 0; i < sizeof(kHandledProtocols) / sizeof(char*);
2532 i++) {
2533 handled = (proto == kHandledProtocols[i]);
2534 if (handled)
2535 break;
2536 }
2537
2538 if (handled) {
2539 // This is the easy case, a complete and well-formed URL, we can
2540 // navigate to it without further efforts.
2541 _VisitURL(url);
2542 return;
2543 } else {
2544 // There is what looks like a protocol, but one we don't know.
2545 // Ask the BRoster if there is a matching filetype and app which
2546 // can handle it.
2547 BString temp;
2548 temp = "application/x-vnd.Be.URL.";
2549 temp += proto;
2550
2551 const char* argv[] = { url.String(), NULL };
2552
2553 if (be_roster->Launch(temp.String(), 1, argv) == B_OK)
2554 return;
2555 }
2556 }
2557
2558 // There is no protocol or only an unsupported one. So let's try harder to
2559 // guess what the request is.
2560
2561 // "localhost" is a special case, it is a valid domain name but has no dots.
2562 // Handle it separately.
2563 if (url == "localhost")
2564 _VisitURL("http://localhost/");
2565 else {
2566 // Also handle URLs starting with "localhost" followed by a path.
2567 const char* localhostPrefix = "localhost/";
2568
2569 if (url.Compare(localhostPrefix, strlen(localhostPrefix)) == 0)
2570 _VisitURL(url);
2571 else {
2572 // In all other cases we try to detect a valid domain name. There
2573 // must be at least one dot and no spaces until the first / in the
2574 // URL.
2575 bool isURL = false;
2576
2577 for (int32 i = 0; i < url.CountChars(); i++) {
2578 if (url[i] == '.')
2579 isURL = true;
2580 else if (url[i] == '/')
2581 break;
2582 else if (!_IsValidDomainChar(url[i])) {
2583 isURL = false;
2584
2585 break;
2586 }
2587 }
2588
2589 if (isURL) {
2590 // This is apparently an URL missing the protocol part. In that
2591 // case we default to http.
2592 BString prefixed = "http://";
2593 prefixed << url;
2594 _VisitURL(prefixed);
2595 return;
2596 } else {
2597 // We couldn't find anything that looks like an URL. Let's
2598 // assume what we have is a search request and go to the search
2599 // engine.
2600 _VisitSearchEngine(url);
2601 }
2602 }
2603 }
2604 }
2605
2606
2607 void
2608 BrowserWindow::_HandlePageSourceResult(const BMessage* message)
2609 {
2610 // TODO: This should be done in an extra thread perhaps. Doing it in
2611 // the application thread is not much better, since it actually draws
2612 // the pages...
2613
2614 BPath pathToPageSource;
2615
2616 BString url;
2617 status_t ret = message->FindString("url", &url);
2618 if (ret == B_OK && url.FindFirst("file://") == 0) {
2619 // Local file
2620 url.Remove(0, strlen("file://"));
2621 pathToPageSource.SetTo(url.String());
2622 } else {
2623 // Something else, store it.
2624 // TODO: What if it isn't HTML, but for example SVG?
2625 BString source;
2626 ret = message->FindString("source", &source);
2627
2628 if (ret == B_OK)
2629 ret = find_directory(B_SYSTEM_TEMP_DIRECTORY, &pathToPageSource);
2630
2631 BString tmpFileName("PageSource_");
2632 tmpFileName << system_time() << ".html";
2633 if (ret == B_OK)
2634 ret = pathToPageSource.Append(tmpFileName.String());
2635
2636 BFile pageSourceFile(pathToPageSource.Path(),
2637 B_CREATE_FILE | B_ERASE_FILE | B_WRITE_ONLY);
2638 if (ret == B_OK)
2639 ret = pageSourceFile.InitCheck();
2640
2641 if (ret == B_OK) {
2642 ssize_t written = pageSourceFile.Write(source.String(),
2643 source.Length());
2644 if (written != source.Length())
2645 ret = (status_t)written;
2646 }
2647
2648 if (ret == B_OK) {
2649 const char* type = "text/html";
2650 size_t size = strlen(type);
2651 pageSourceFile.WriteAttr("BEOS:TYPE", B_STRING_TYPE, 0, type, size);
2652 // If it fails we don't care.
2653 }
2654 }
2655
2656 entry_ref ref;
2657 if (ret == B_OK)
2658 ret = get_ref_for_path(pathToPageSource.Path(), &ref);
2659
2660 if (ret == B_OK) {
2661 BMessage refsMessage(B_REFS_RECEIVED);
2662 ret = refsMessage.AddRef("refs", &ref);
2663 if (ret == B_OK) {
2664 ret = be_roster->Launch("text/x-source-code", &refsMessage);
2665 if (ret == B_ALREADY_RUNNING)
2666 ret = B_OK;
2667 }
2668 }
2669
2670 if (ret != B_OK) {
2671 char buffer[1024];
2672 snprintf(buffer, sizeof(buffer), "Failed to show the "
2673 "page source: %s\n", strerror(ret));
2674 BAlert* alert = new BAlert(B_TRANSLATE("Page source error"), buffer,
2675 B_TRANSLATE("OK"));
2676 alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
2677 alert->Go(NULL);
2678 }
2679 }
2680
2681
2682 void
2683 BrowserWindow::_ShowBookmarkBar(bool show)
2684 {
2685 // It is not allowed to show the bookmark bar when it is empty
2686 if (show && (fBookmarkBar == NULL || fBookmarkBar->CountItems() <= 1))
2687 {
2688 fBookmarkBarMenuItem->SetMarked(false);
2689 return;
2690 }
2691
2692 fBookmarkBarMenuItem->SetMarked(show);
2693
2694 if (fBookmarkBar == NULL || fBookmarkBar->IsHidden() != show)
2695 return;
2696
2697 fAppSettings->SetValue(kSettingsShowBookmarkBar, show);
2698
2699 if (show)
2700 fBookmarkBar->Show();
2701 else
2702 fBookmarkBar->Hide();
2703 }
Clone of Haiku svn repository