fixup commit for tag 'kmeleon74'

km74 kmeleon74
cvs2hg 8 years ago
commit ff0bca530d
  1. 80
      k-meleon/About.cpp
  2. 40
      k-meleon/About.h
  3. 482
      k-meleon/AccelParser.cpp
  4. 62
      k-meleon/AccelParser.h
  5. 152
      k-meleon/AutoComplete.h
  6. 956
      k-meleon/BrowserFrameGlue.cpp
  7. 1857
      k-meleon/BrowserFrm.cpp
  8. 378
      k-meleon/BrowserFrm.h
  9. 935
      k-meleon/BrowserFrmTab.cpp
  10. 189
      k-meleon/BrowserFrmTab.h
  11. 658
      k-meleon/BrowserGlue.cpp
  12. 1129
      k-meleon/BrowserImpl.cpp
  13. 127
      k-meleon/BrowserImpl.h
  14. 88
      k-meleon/BrowserImplCtxMenuLstnr.cpp
  15. 194
      k-meleon/BrowserImplWebPrgrsLstnr.cpp
  16. 1099
      k-meleon/BrowserView.cpp
  17. 339
      k-meleon/BrowserView.h
  18. 220
      k-meleon/BrowserViewFind.cpp
  19. 220
      k-meleon/BrowserViewPanning.cpp
  20. 557
      k-meleon/BrowserViewUtils.cpp
  21. 2037
      k-meleon/BrowserWindow.cpp
  22. 370
      k-meleon/BrowserWindow.h
  23. 187
      k-meleon/CmdLine.cpp
  24. 12
      k-meleon/CmdLine.h
  25. 75
      k-meleon/Components.cpp
  26. 81
      k-meleon/ContentDispatchChooser.cpp
  27. 13
      k-meleon/ContentDispatchChooser.h
  28. 149
      k-meleon/CookiePromptService.cpp
  29. 81
      k-meleon/CookiePromptService.h
  30. 88
      k-meleon/Cookies.h
  31. 251
      k-meleon/CookiesViewerDlg.cpp
  32. 63
      k-meleon/CookiesViewerDlg.h
  33. 9
      k-meleon/DPIaware.manifest
  34. 225
      k-meleon/DialogEx.h
  35. 186
      k-meleon/DialogUtils.cpp
  36. 39
      k-meleon/DialogUtils.h
  37. 696
      k-meleon/Dialogs.cpp
  38. 183
      k-meleon/Dialogs.h
  39. 858
      k-meleon/FavIconList.cpp
  40. 89
      k-meleon/FavIconList.h
  41. 212
      k-meleon/FontPackageHandler.cpp
  42. 88
      k-meleon/FontPackageHandler.h
  43. 112
      k-meleon/GenKeyPairDialogs.cpp
  44. 75
      k-meleon/GenKeyPairDialogs.h
  45. 443
      k-meleon/GenericDlg.cpp
  46. 140
      k-meleon/GenericDlg.h
  47. 355
      k-meleon/HiddenWnd.cpp
  48. 83
      k-meleon/HiddenWnd.h
  49. 199
      k-meleon/IBrowserFrameGlue.h
  50. 340
      k-meleon/Install/GNUlicense.txt
  51. BIN
      k-meleon/Install/K-Meleon.bmp
  52. 1
      k-meleon/Install/K-MeleonUNINST.ini
  53. 916
      k-meleon/Install/License.txt
  54. 981
      k-meleon/Install/SetDefault.nsi
  55. 50
      k-meleon/Install/english.nlf
  56. BIN
      k-meleon/Install/install.ico
  57. BIN
      k-meleon/Install/k-meleon.ico
  58. 728
      k-meleon/Install/k-meleon.nsi
  59. BIN
      k-meleon/Install/makensis.exe
  60. 118
      k-meleon/Install/readme.txt
  61. BIN
      k-meleon/Install/uninstall.ico
  62. 21
      k-meleon/JSBridge/JSBridge.sln
  63. 188
      k-meleon/JSBridge/JSBridge.vcproj
  64. 125
      k-meleon/JSBridge/JSBridge.vcxproj
  65. 2
      k-meleon/JSBridge/genidl.cmd
  66. 129
      k-meleon/JSBridge/jscomp.cpp
  67. 40
      k-meleon/JSBridge/jscomp.h
  68. 166
      k-meleon/JSBridge/jsplugin.cpp
  69. 208
      k-meleon/JSBridge/nsGenericFactory.cpp
  70. 50
      k-meleon/JSBridge/nsIJSBridge.idl
  71. 540
      k-meleon/KMeleon.dsp
  72. 185
      k-meleon/KMeleon.dsw
  73. 293
      k-meleon/KMeleon.sln
  74. 1046
      k-meleon/KMeleon.vcproj
  75. 368
      k-meleon/KMeleon.vcxproj
  76. 430
      k-meleon/KMeleon.vcxproj.filters
  77. 133
      k-meleon/KMeleon10.sln
  78. 99
      k-meleon/KMeleonConst.h
  79. 106
      k-meleon/KmAbout.cpp
  80. 37
      k-meleon/KmAbout.h
  81. 301
      k-meleon/KmAppInfo.cpp
  82. 39
      k-meleon/KmAppInfo.h
  83. 211
      k-meleon/KmCommand.cpp
  84. 175
      k-meleon/KmCommand.h
  85. 521
      k-meleon/KmFileLocProvider.cpp
  86. 74
      k-meleon/KmFileLocProvider.h
  87. 390
      k-meleon/KmMenu.cpp
  88. 227
      k-meleon/KmMenu.h
  89. 200
      k-meleon/LangParser.cpp
  90. 58
      k-meleon/LangParser.h
  91. 417
      k-meleon/LocalesUtils.h
  92. 223
      k-meleon/Log.h
  93. 217
      k-meleon/MenuParser.cpp
  94. 45
      k-meleon/MenuParser.h
  95. 1793
      k-meleon/MfcEmbed.cpp
  96. 206
      k-meleon/MfcEmbed.h
  97. 1590
      k-meleon/MfcEmbed.rc
  98. 112
      k-meleon/MostRecentUrls.cpp
  99. 40
      k-meleon/MostRecentUrls.h
  100. 552
      k-meleon/MozUtils.cpp
  101. Some files were not shown because too many files have changed in this diff Show More

@ -0,0 +1,80 @@
/*
* Copyright (C) 2001 Jeff Doozan
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "StdAfx.h"
#include "version.h"
#include "About.h"
#include "BrowserFrm.h"
#include "MfcEmbed.h"
extern CMfcEmbedApp theApp;
#define _QUOTE(blah) #blah
CAboutDlg::CAboutDlg(CWnd *wndParent) : CDialog(CAboutDlg::IDD, wndParent)
{
m_credits = _QUOTE(
\r\n
K-Meleon - Copyright 2000-2003\r\n
\r\n
Uses the Gecko rendering engine by the Mozilla Group\r\n
Based on MfcEmbed\r\n
\r\n
Core Developers:\r\n
Jeff Doozan <jeff@tcbmi.com>\r\n
Brian Harris <binaryc@teamreaction.com>\r\n
Mark Liffiton <liffiton@simons-rock.edu>\r\n
\r\n
Plugin Developers:\r\n
Ulf Erikson <ulferikson@fastmail.fm>\r\n
Rob Johnson <rob@rob-johnson.net>\r\n
\r\n
Project Documentation:\r\n
Andrew Mutch <amutch@tln.lib.mi.us>\r\n
\r\n
Past Contributors:\r\n
Sebastian Spaeth <Sebastian@SSpaeth.de>\r\n
Christophe Thibault <christophe@nullsoft.com>\r\n
Chak Nanga <chak@netscape.com>\r\n
);
m_version.Format("Version %s Build %d Compiled %s", VERSION, BUILD_NUMBER, BUILD_TIME);
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX){
DDX_Text(pDX, IDC_CREDITS, m_credits);
DDX_Text(pDX, IDC_VERSION, m_version);
CDialog::DoDataExchange(pDX);
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CMfcEmbedApp)
ON_COMMAND(IDC_KMELEON_HOME, OnHome)
ON_COMMAND(IDC_KMELEON_FORUM, OnForum)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
void CAboutDlg::OnHome() {
if (theApp.m_pMostRecentBrowserFrame)
theApp.m_pMostRecentBrowserFrame->PostMessage(WM_COMMAND, ID_LINK_KMELEON_HOME);
}
void CAboutDlg::OnForum() {
if (theApp.m_pMostRecentBrowserFrame)
theApp.m_pMostRecentBrowserFrame->PostMessage(WM_COMMAND, ID_LINK_KMELEON_FORUM);
}

@ -0,0 +1,40 @@
/*
* Copyright (C) 2001 Jeff Doozan
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "resource.h"
#include "BrowserView.h"
#include "DialogEx.h"
class CAboutDlg : public CDialog
{
public:
CAboutDlg(CWnd *wndParent);
enum { IDD = IDD_ABOUTBOX };
protected:
CString m_credits;
CString m_version;
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
protected:
afx_msg void OnHome();
afx_msg void OnForum();
DECLARE_MESSAGE_MAP()
};

@ -0,0 +1,482 @@
/*
* Copyright (C) 2000 Brian Harris
* Copyright (C) 2006 Dorian Boissonnade
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "StdAfx.h"
#include "MfcEmbed.h"
#include "AccelParser.h"
#include "Utils.h"
#include "resource.h"
#include "Plugins.h"
#define BEGIN_VK_TEST if (0){}
#define VK_TEST(KEY) else if (stricmp(p, #KEY) == 0){ key = VK_##KEY; }
// a few that winuser.h doesn't have for some reason (snagged from msdn)
#define VK_OEM_PLUS 0xBB
#define VK_OEM_COMMA 0xBC
#define VK_OEM_MINUS 0xBD
#define VK_OEM_PERIOD 0xBE
// and some more friendly definitions...
#define VK_PLUS VK_OEM_PLUS
#define VK_EQUALS VK_OEM_PLUS
#define VK_MINUS VK_OEM_MINUS
#define VK_COMMA VK_OEM_COMMA
#define VK_PERIOD VK_OEM_PERIOD
#define VK_PERIOD VK_OEM_PERIOD
#define VK_PAGE_UP VK_PRIOR
#define VK_PAGE_DOWN VK_NEXT
//Standard accel to show in menu
static const ACCEL stdAccels[] = {
{FCONTROL, 'C', ID_EDIT_COPY},
{FCONTROL, 'V', ID_EDIT_PASTE},
{FCONTROL, 'X', ID_EDIT_CUT},
{FVIRTKEY|FALT, VK_F4, ID_FILE_CLOSE}
};
extern BOOL ParsePluginCommand(char *pszCommand, char** plugin, char **parameter);
CAccelParser::CAccelParser()
{
accelTable = NULL;
numAccelerators = 0;
memset(accelerators, 0, sizeof(ACCEL) * MAX_ACCEL);
numMKeys = 0;
memset(mouse, 0, sizeof(ACCEL) * MAX_MOUSE);
}
CAccelParser::CAccelParser(LPCTSTR filename)
{
accelTable = NULL;
numAccelerators = 0;
memset(accelerators, 0, sizeof(ACCEL) * MAX_ACCEL);
Load(filename);
}
CAccelParser::~CAccelParser()
{
if (accelTable){
DestroyAcceleratorTable(accelTable);
}
}
int CAccelParser::Load(LPCTSTR filename)
{
SETUP_LOG("Accel");
if (accelTable){
DestroyAcceleratorTable(accelTable);
accelTable = NULL;
numAccelerators = 0;
}
int retVal = CParser::Load(filename);
END_LOG();
return retVal;
}
int CAccelParser::Parse(char *p)
{
// <modifiers> <key> = <command>
char *e = strchr(p, '=');
if (e){
*e = 0;
e++;
e = SkipWhiteSpace(e);
TrimWhiteSpace(e);
TrimWhiteSpace(p);
return SetAccel(p, e);
}
return 0;
}
int CAccelParser::SetAccel(const char* pKey, const char* pCommand)
{
int command = 0;
const char *alt, *ctrl, *shift;
const char* p;
BYTE virt;
int key;
command = theApp.commands.GetId(pCommand);
if (!command) {
LOG_ERROR_1( "Command %s is unknow", pCommand);
//return 0;
}
virt = 0;
p = pKey;
alt = strstr(pKey, "ALT");
if (alt){
virt |= FALT;
p = alt + 3;
}
ctrl = strstr(pKey, "CTRL");
if (ctrl){
virt |= FCONTROL;
if (ctrl > alt){
p = ctrl + 4;
}
}
shift = strstr(pKey, "SHIFT");
if (shift){
virt |= FSHIFT;
if ((shift > alt) && (shift > ctrl)){
p = shift + 5;
}
}
// by now, p should be past the modifiers and point to " <key>"
p = SkipWhiteSpace((char*)p);
if (strncmp(p, "VK_", 3) == 0){
p+=3;
key = 0;
// these should be in order of frequency of use to speed up parsing
BEGIN_VK_TEST
VK_TEST(ESCAPE)
VK_TEST(LEFT)
VK_TEST(RIGHT)
VK_TEST(F1)
VK_TEST(F2)
VK_TEST(F3)
VK_TEST(F4)
VK_TEST(F5)
VK_TEST(F6)
VK_TEST(F7)
VK_TEST(F8)
VK_TEST(F9)
VK_TEST(F10)
VK_TEST(F11)
VK_TEST(F12)
VK_TEST(HOME)
VK_TEST(END)
VK_TEST(PRIOR) // page up
VK_TEST(NEXT) // page down
VK_TEST(PAGE_UP)
VK_TEST(PAGE_DOWN)
VK_TEST(UP)
VK_TEST(DOWN)
VK_TEST(INSERT)
VK_TEST(DELETE)
VK_TEST(SPACE)
VK_TEST(HELP)
VK_TEST(EXECUTE)
VK_TEST(SELECT)
VK_TEST(PRINT)
VK_TEST(SNAPSHOT) // print screen?
VK_TEST(PLUS)
VK_TEST(MINUS)
VK_TEST(COMMA)
VK_TEST(PERIOD)
VK_TEST(EQUALS)
VK_TEST(BACK)
VK_TEST(TAB)
VK_TEST(CLEAR)
VK_TEST(RETURN)
VK_TEST(MULTIPLY)
VK_TEST(ADD)
VK_TEST(SUBTRACT)
VK_TEST(DECIMAL)
VK_TEST(DIVIDE)
VK_TEST(SEPARATOR)
VK_TEST(PAUSE)
VK_TEST(CAPITAL)
VK_TEST(MENU)
VK_TEST(BROWSER_BACK)
VK_TEST(BROWSER_FORWARD)
VK_TEST(BROWSER_REFRESH)
VK_TEST(BROWSER_STOP)
VK_TEST(BROWSER_SEARCH)
VK_TEST(BROWSER_FAVORITES)
VK_TEST(BROWSER_HOME)
/*
VK_TEST(KANA)
VK_TEST(JUNJA)
VK_TEST(FINAL)
VK_TEST(HANJA)
VK_TEST(KANJI)
VK_TEST(CONVERT)
VK_TEST(NONCONVERT)
VK_TEST(ACCEPT)
VK_TEST(MODECHANGE)
*/
VK_TEST(LWIN)
VK_TEST(RWIN)
VK_TEST(APPS)
VK_TEST(NUMPAD0)
VK_TEST(NUMPAD1)
VK_TEST(NUMPAD2)
VK_TEST(NUMPAD3)
VK_TEST(NUMPAD4)
VK_TEST(NUMPAD5)
VK_TEST(NUMPAD6)
VK_TEST(NUMPAD7)
VK_TEST(NUMPAD8)
VK_TEST(NUMPAD9)
/*
VK_TEST(F13)
VK_TEST(F14)
VK_TEST(F15)
VK_TEST(F16)
VK_TEST(F17)
VK_TEST(F18)
VK_TEST(F19)
VK_TEST(F20)
VK_TEST(F21)
VK_TEST(F22)
VK_TEST(F23)
VK_TEST(F24)
*/
VK_TEST(NUMLOCK)
VK_TEST(SCROLL)
}
else if (stricmp(p, "LButton") == 0){
SetMAccel(command, virt, WM_LBUTTONDOWN);
return true;
}
else if (stricmp(p, "MButton") == 0){
SetMAccel(command, virt, WM_MBUTTONDOWN);
return true;
}
else if (stricmp(p, "RButton") == 0){
SetMAccel(command, virt, WM_RBUTTONDOWN);
return true;
}
else {
// regular key, convert it to virtual-key code to
// get the associated key on the keyboard.
key = VkKeyScanA(*p) & 0xff;
}
virt |= FVIRTKEY;
SetAccel(command, virt, key);
LOG_2("Added accelerator %s with command %s", pKey, pCommand);
return true;
}
void CAccelParser::SetAccel(WORD command, BYTE virt, WORD key)
{
int oldAccel = FindAccel(virt, key);
if (command != 0 && oldAccel == -1) {
accelerators[numAccelerators].cmd = command;
accelerators[numAccelerators].fVirt = virt;
accelerators[numAccelerators].key = key;
numAccelerators++;
}
else {
if (command != 0)
accelerators[oldAccel].cmd = command;
else if (oldAccel>=0)
DeleteAccel(oldAccel);
}
if (accelTable) {
DestroyAcceleratorTable(accelTable);
accelTable = NULL;
}
}
void CAccelParser::SetMAccel(WORD command, BYTE virt, WORD button)
{
int oldAccel = FindMAccel(virt, button);
if (command == 0) {
if(oldAccel != -1)
DeleteMAccel(oldAccel);
return;
}
if (oldAccel != -1) {
mouse[oldAccel].cmd = command;
return;
}
mouse[numMKeys].cmd = command;
mouse[numMKeys].fVirt = virt;
mouse[numMKeys].key = button;
numMKeys++;
}
void CAccelParser::DeleteMAccel(int idx)
{
ASSERT(idx>=0&&idx<=MAX_MOUSE);
int i;
--numMKeys;
for (i=idx;i<numMKeys;i++)
mouse[i] = mouse[i+1];
}
void CAccelParser::DeleteAccel(int idx)
{
ASSERT(idx>=0&&idx<=MAX_ACCEL);
int i;
--numAccelerators;
for (i=idx;i<numAccelerators;i++)
accelerators[i] = accelerators[i+1];
}
int CAccelParser::FindMAccel(WORD virt, DWORD key)
{
const ACCEL* accel = NULL;
for (int i=0;i<numAccelerators;i++)
if (mouse[i].key == key && mouse[i].fVirt == virt)
return i;
return -1;
}
int CAccelParser::FindAccel(WORD virt, DWORD key)
{
const ACCEL* accel = NULL;
for (int i=0;i<numAccelerators;i++)
if (accelerators[i].key == key && accelerators[i].fVirt == virt)
return i;
return -1;
}
HACCEL CAccelParser::GetTable(){
if (!accelTable){
accelTable = CreateAcceleratorTable(accelerators, numAccelerators);
}
return accelTable;
}
CString CAccelParser::GetStrAccel(UINT id)
{
const ACCEL* accel = NULL;
for (int i=0;i<numAccelerators;i++) {
if (accelerators[i].cmd == id) {
accel = &accelerators[i];
break;
}
}
if (!accel) {
for (int i=0;i<sizeof(stdAccels)/sizeof(ACCEL);i++) {
if (stdAccels[i].cmd == id) {
accel = &stdAccels[i];
break;
}
}
}
if (accel) {
CString str;
TCHAR buf[25];
if(accel->fVirt & FCONTROL) {
GetKeyNameText(MapVirtualKey(VK_CONTROL, 0)<<16, buf, sizeof(buf) / sizeof(TCHAR));
if (*buf) {
CharLowerBuff(buf+1, _tcslen(buf)-1);
str = str + buf + _T("+");
}
}
if(accel->fVirt & FSHIFT) {
GetKeyNameText(MapVirtualKey(VK_SHIFT, 0)<<16, buf, sizeof(buf) / sizeof(TCHAR));
if (*buf) {
CharLowerBuff(buf+1, _tcslen(buf)-1);
str = str + buf + _T("+");
}
}
if(accel->fVirt & FALT) {
GetKeyNameText(MapVirtualKey(VK_MENU, 0)<<16, buf, sizeof(buf) / sizeof(TCHAR));
if (*buf) {
CharLowerBuff(buf+1, _tcslen(buf)-1);
str = str + buf + _T("+");
}
}
if(accel->fVirt & FVIRTKEY) {
WORD key = accel->key;
UINT scan = MapVirtualKey(key, 0);
if ((key >= VK_PRIOR) && (key<=VK_DELETE))
scan |= 0x100; // should remove the numpad text
if (GetKeyNameText(scan<<16 , buf, sizeof(buf) / sizeof(TCHAR)) == 0)
return _T("");
// Since I can't find a way to remove the numpad indication
// for /,* or . I'm removing it the hard way.
TCHAR* parenthesis = _tcschr(buf, '(');
if (parenthesis && parenthesis>buf)
*parenthesis = 0;
if (*buf) {
CharLowerBuff(buf+1, _tcslen(buf)-1);
str += buf;
}
}
else {
char c[2] = { accel->key & 0xff, '\0' };
USES_CONVERSION;
str += A2CT(c);
}
return str;
}
return _T("");
}
int CAccelParser::CheckMouse(UINT message){
int i, virt = 0;
virt = message >> 8;
switch (message & 0xff) {
case MK_LBUTTON: message = WM_LBUTTONDOWN; break;
case MK_RBUTTON: message = WM_RBUTTONDOWN; break;
case MK_MBUTTON: message = WM_MBUTTONDOWN; break;
default : ;
}
for (i=0; i<numMKeys; i++) {
if (mouse[i].key == message) {
if (mouse[i].fVirt == virt)
return mouse[i].cmd;
}
}
return 0;
}

@ -0,0 +1,62 @@
/*
* Copyright (C) 2000 Brian Harris
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __ACCELPARSER_H__
#define __ACCELPARSER_H__
#include "StdAfx.h"
#include "Parser.h"
#define MAX_ACCEL 127
#define MAX_MOUSE 12
class CAccelParser : public CParser {
protected:
ACCEL accelerators[MAX_ACCEL];
int numAccelerators;
ACCEL mouse[MAX_MOUSE];
int numMKeys;
HACCEL accelTable;
void DeleteAccel(int idx);
void DeleteMAccel(int idx);
int FindAccel(WORD virt, DWORD key);
int FindMAccel(WORD virt, DWORD key);
public:
CAccelParser();
CAccelParser(LPCTSTR filename);
~CAccelParser();
int Load(LPCTSTR filename);
int Parse(char *p);
int SetAccel(const char* key, const char* command);
void SetAccel(WORD command, BYTE virt, WORD key);
void SetMAccel(WORD command, BYTE virt, WORD button);
HACCEL GetTable();
CString GetStrAccel(UINT id);
int CheckMouse(UINT message);
};
#endif // __ACCELPARSER_H__

@ -0,0 +1,152 @@
/*
* Copyright (C) 2005 Dorian Boissonnade
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// Temporary (maybe not) fix for autocompletion
#pragma once
#include "stdafx.h"
#include "nsIAutoCompleteSearch.h"
#include "nsIAutoCompleteResult.h"
#include "kmeleon_plugin.h"
#include "MozUtils.h"
typedef void (CALLBACK* AutoCompleteCallback)(_AutoCompleteResult*, int, void*) ;
class CACListener : public nsIAutoCompleteObserver
{
NS_DECL_ISUPPORTS
NS_DECL_NSIAUTOCOMPLETEOBSERVER
CACListener::CACListener(AutoCompleteCallback callback, void* data) {
m_ACIt = NULL;
m_Callback = callback;
m_data = data;
gACResults = nullptr;
gACCountResults = 0;
}
CACListener::~CACListener() {
FreeResult();
}
static void AutoCompleteStop();
static void AutoComplete(const CString& aSearchString, AutoCompleteCallback callback, void* data);
protected:
void FreeResult() {
if (gACCountResults > 0) {
m_ACIt = gACResults;
while (gACCountResults--){
free(m_ACIt->value);
free(m_ACIt->comment);
m_ACIt++;
}
free(gACResults);
gACResults = NULL;
gACCountResults = 0;
}
}
PRBool AddEltToList(nsISupports* aElement);
nsCOMPtr<nsIAutoCompleteResult> m_oldResult;
AutoCompleteResult* gACResults ;
unsigned int gACCountResults;
AutoCompleteResult* m_ACIt;
AutoCompleteCallback m_Callback;
void* m_data;
static nsEmbedString previousSearch;
};
NS_IMPL_ISUPPORTS1(CACListener, nsIAutoCompleteObserver)
NS_IMETHODIMP CACListener::OnUpdateSearchResult(nsIAutoCompleteSearch *search, nsIAutoCompleteResult *result)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP CACListener::OnSearchResult(nsIAutoCompleteSearch *search, nsIAutoCompleteResult *result)
{
FreeResult();
uint16_t status;
result->GetSearchResult(&status);
int32_t defaultIndex;
result->GetDefaultIndex(&defaultIndex);
if (status == nsIAutoCompleteResult::RESULT_SUCCESS || status == nsIAutoCompleteResult::RESULT_NOMATCH)
{
m_oldResult = result; // Keep the old result for optimization
result->GetMatchCount(&gACCountResults);
gACResults = (AutoCompleteResult*)calloc(gACCountResults, sizeof(AutoCompleteResult));
m_ACIt = gACResults;
for (PRUint32 i = 0; i<gACCountResults; i++)
{
nsEmbedString nsStr;
nsEmbedCString nsCStr;
result->GetValueAt(i, nsStr);
NS_UTF16ToCString(nsStr,NS_CSTRING_ENCODING_NATIVE_FILESYSTEM,nsCStr);
m_ACIt->value = strdup(nsCStr.get());
result->GetCommentAt(i, nsStr);
NS_UTF16ToCString(nsStr,NS_CSTRING_ENCODING_NATIVE_FILESYSTEM,nsCStr);
m_ACIt->comment = strdup(nsCStr.get());
m_ACIt->score = 0;
m_ACIt++;
}
(*m_Callback)(gACResults, gACCountResults, m_data);
}
else
m_oldResult = nullptr;
return NS_OK;
}
nsEmbedString CACListener::previousSearch;
void CACListener::AutoCompleteStop()
{
nsresult rv;
nsCOMPtr<nsIAutoCompleteSearch> autoComplete = do_GetService("@mozilla.org/autocomplete/search;1?name=history", &rv);
NS_ENSURE_TRUE(autoComplete, );
autoComplete->StopSearch();
previousSearch = L"";
}
void CACListener::AutoComplete(const CString& aSearchString, AutoCompleteCallback callback, void* data)
{
nsresult rv;
nsCOMPtr<nsIAutoCompleteSearch> autoComplete = do_GetService("@mozilla.org/autocomplete/search;1?name=history", &rv);
NS_ENSURE_TRUE(autoComplete, );
nsEmbedString searchString = CStringToNSString(aSearchString);
if (!searchString.Equals(previousSearch)) {
previousSearch = searchString;
nsCOMPtr<nsIAutoCompleteObserver> listener = new CACListener(callback, data);
autoComplete->StartSearch(searchString, EmptyString(), nullptr/*m_oldResult*/, listener);
}
}

@ -0,0 +1,956 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: Mozilla-sample-code 1.0
*
* Copyright (c) 2002 Netscape Communications Corporation and
* other contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this Mozilla sample software and associated documentation files
* (the "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to permit
* persons to whom the Software is furnished to do so, subject to the
* following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Contributor(s):
* Chak Nanga <chak@netscape.com>
*
* ***** END LICENSE BLOCK ***** */
// File Overview....
//
// This file has the IBrowserFrameGlueObj implementation
// This frame glue object is nested inside of the BrowserFrame
// object(See BrowserFrm.h for more info)
//
// This is the place where all the platform specific interaction
// with the browser frame window takes place in response to
// callbacks from Gecko interface methods
//
// The main purpose of this interface is to separate the cross
// platform code in BrowserImpl*.cpp from the platform specific
// code(which is in this file)
//
// You'll also notice the use of a macro named "METHOD_PROLOGUE"
// through out this file. This macro essentially makes the pointer
// to a "containing" class available inside of the class which is
// being contained via a var named "pThis". In our case, the
// BrowserFrameGlue object is contained inside of the BrowserFrame
// object so "pThis" will be a pointer to a BrowserFrame object
// Refer to MFC docs for more info on METHOD_PROLOGUE macro
#include "stdafx.h"
#include "MfcEmbed.h"
#include "BrowserFrm.h"
#include "Dialogs.h"
#include "MenuParser.h"
#include "KmeleonConst.h"
#include "nsIDOMHTMLAreaElement.h"
#include "nsIDOMHTMLInputElement.h"
extern CMfcEmbedApp theApp;
extern nsresult NewURI(nsIURI **result, const nsACString &spec);
/////////////////////////////////////////////////////////////////////////////
// IBrowserFrameGlue implementation
void CBrowserFrame::BrowserFrameGlueObj::UpdateStatusBarText(const PRUnichar *aMessage)
{
#ifndef _UNICODE
if (aMessage && (wcslen(aMessage) > 1024)) return;
#endif
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
USES_CONVERSION;
CString str;
if (aMessage && wcslen(aMessage) > 0)
str = W2CT(aMessage);
else
str.LoadString(AFX_IDS_IDLEMESSAGE);
pThis->m_wndStatusBar.SetPaneText(0, str);
}
void CBrowserFrame::BrowserFrameGlueObj::UpdateProgress(PRInt32 aCurrent, PRInt32 aMax)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
pThis->m_wndProgressBar.SetRange32(0, aMax);
pThis->m_wndProgressBar.SetPos(aCurrent);
}
void CBrowserFrame::BrowserFrameGlueObj::UpdateBusyState(PRBool aBusy)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
// Just notify the view of the busy state
// There's code in there which will take care of
// updating the STOP toolbar btn. etc
pThis->m_wndBrowserView.UpdateBusyState(aBusy);
//if (!aBusy)
pThis->PostMessage(UWM_UPDATEBUSYSTATE, aBusy == PR_TRUE ? 1 : 0, pThis->m_wndBrowserView.m_hWnd);
if (!aBusy) {
CString szUrl;
pThis->m_wndUrlBar.GetEnteredURL(szUrl);
if (_tcscmp(szUrl, _T("about:blank"))==0)
pThis->m_wndUrlBar.MaintainFocus();
// XXX We have to resize XUL dialog manually. They should have they own
// glue and window object!
if (pThis->m_bSizeOnLoad) {
nsCOMPtr<nsIDOMWindow> domWindow;
pThis->m_wndBrowserView.mWebBrowser->GetContentDOMWindow(getter_AddRefs(domWindow));
if (domWindow)
domWindow->SizeToContent();
// It must be repositionned somewhat after the resize. Centering it
// all the time is not that bad.
//if (pThis->m_chromeMask & nsIWebBrowserChrome::CHROME_CENTER_SCREEN)
pThis->CenterWindow();
pThis->ShowWindow(SW_SHOW);
pThis->UpdateWindow();
pThis->m_bSizeOnLoad = FALSE;
}
}
else
pThis->m_wndBrowserView.mbDOMLoaded = FALSE;
pThis->m_wndBrowserView.m_lastMouseActionNode = nsnull;
}
// Called from the OnLocationChange() method in the nsIWebProgressListener
// interface implementation in CBrowserImpl to update the current URI
// Will get called after a URI is successfully loaded in the browser
// We use this info to update the URL bar's edit box
//
void CBrowserFrame::BrowserFrameGlueObj::UpdateCurrentURI(nsIURI *aLocation)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if(aLocation)
{
USES_CONVERSION;
nsEmbedCString uriString;
aLocation->GetSpec(uriString);
nsEmbedString uriString2;
NS_CStringToUTF16(uriString, NS_CSTRING_ENCODING_UTF8, uriString2);
// Reset the popup notification and the icon uri
if (!(pThis->m_wndBrowserView.m_csHostPopupBlocked.IsEmpty())) {
pThis->m_wndStatusBar.RemoveIcon(ID_POPUP_BLOCKED_ICON);
pThis->m_wndBrowserView.m_csHostPopupBlocked.Empty();
}
#ifdef INTERNAL_SITEICONS
// Must be done here, before testing if we have the same address
// because xul error page have its own icon, and since the address
// doesn't change when retrying, the icon may stay in the urlbar.
pThis->m_wndBrowserView.m_IconUri = nsnull;
#endif
// Prevent to move the caret in the urlbar
CString currentURL;
pThis->m_wndUrlBar.GetEnteredURL(currentURL);
if (currentURL.Compare(W2CT(uriString2.get())) == 0)
return;
// XXX Since Mozilla 1.8.0.2 about:blank is always passed here
// before anything else, broking stuffs, so ignore it!
if ( stricmp (uriString.get(), "about:blank") == 0 &&
currentURL.GetLength())
return;
pThis->m_wndUrlBar.SetCurrentURL(W2CT(uriString2.get()));
// Add a MRU entry. Note that I'm only only allowing
// http or https uri
PRBool allowMRU,b;
aLocation->SchemeIs("http", &b);
allowMRU = b;
aLocation->SchemeIs("https", &b);
allowMRU |= b;
if ( allowMRU ) {
if (theApp.preferences.MRUbehavior == 0){
nsEmbedCString password;
aLocation->GetUsername(password);
aLocation->SetUserPass(password);
aLocation->GetSpec(uriString);
theApp.m_MRUList->AddURL(A2CT(uriString.get()));
}
else if (theApp.preferences.MRUbehavior == 1){
nsEmbedCString nsScheme, nsHost;
aLocation->GetScheme(nsScheme);
aLocation->GetHost(nsHost);
nsHost.Insert("://",0);
nsHost.Insert(nsScheme,0);
theApp.m_MRUList->AddURL(A2CT(nsHost.get()));
}
}
}
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserFrameTitle(PRUnichar **aTitle)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
CString title;
pThis->GetWindowText(title);
/* TCHAR psz[256];
CString appTitle;
appTitle.LoadString(AFX_IDS_APP_TITLE);
theApp.preferences.GetString("kmeleon.display.title", psz, appTitle.GetBuffer(0));
appTitle = psz;
title.Replace(_T(" (") + appTitle + _T(')'), _T(""));
*/
if(!title.IsEmpty())
{
USES_CONVERSION;
nsEmbedString nsTitle;
nsTitle.Assign(T2CW(title));
*aTitle = NS_StringCloneData(nsTitle);
}
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserFrameTitle(const PRUnichar *aTitle)
{
#ifndef _UNICODE
if (wcslen(aTitle) > 1024) return;
#endif
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
TCHAR psz[256];
CString appTitle;
appTitle.LoadString(AFX_IDS_APP_TITLE);
theApp.preferences.GetString("kmeleon.display.title", psz, appTitle.GetBuffer(0));
appTitle = psz;
CString title;
USES_CONVERSION;
title = W2CT(aTitle);
if (title.IsEmpty()){
pThis->m_wndUrlBar.GetEnteredURL(title);
}
if (!appTitle.IsEmpty())
title += _T(" (") + appTitle + _T(")");
pThis->SetWindowText(title);
pThis->PostMessage(UWM_UPDATESESSIONHISTORY, 0, 0);
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserFrameSize(PRInt32 aCX, PRInt32 aCY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if (pThis->m_ignoreMoveResize > 0) {
pThis->m_ignoreMoveResize--;
return;
}
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
pThis->GetWindowPlacement(&wp);
if (wp.showCmd != SW_SHOWNORMAL)
return;
pThis->SetWindowPos(NULL, 0, 0, aCX, aCY,
SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER
);
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserSize(PRInt32 aCX, PRInt32 aCY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if (pThis->m_ignoreMoveResize > 0) {
pThis->m_ignoreMoveResize--;
return;
}
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
pThis->GetWindowPlacement(&wp);
if (wp.showCmd != SW_SHOWNORMAL)
return;
// first we have to figure out how much bigger the frame is than the view
RECT frameRect, viewRect;
pThis->GetWindowRect(&frameRect);
pThis->m_wndBrowserView.GetClientRect(&viewRect);
int deltax = (frameRect.right - frameRect.left - viewRect.right);
int deltay = (frameRect.bottom - frameRect.top - viewRect.bottom);
pThis->SetWindowPos(NULL, 0, 0, aCX+deltax, aCY+deltay,
SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER
);
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserFrameSize(PRInt32 *aCX, PRInt32 *aCY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
RECT wndRect;
pThis->GetWindowRect(&wndRect);
if (aCX)
*aCX = wndRect.right - wndRect.left;
if (aCY)
*aCY = wndRect.bottom - wndRect.top;
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserSize(PRInt32 *aCX, PRInt32 *aCY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
RECT wndRect;
pThis->m_wndBrowserView.GetClientRect(&wndRect);
if (aCX)
*aCX = wndRect.right - wndRect.left;
if (aCY)
*aCY = wndRect.bottom - wndRect.top;
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserFramePosition(PRInt32 aX, PRInt32 aY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if (pThis->m_ignoreMoveResize > 0) {
pThis->m_ignoreMoveResize--;
return;
}
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
pThis->GetWindowPlacement(&wp);
if (wp.showCmd != SW_SHOWNORMAL)
return;
pThis->SetWindowPos(NULL, aX, aY, 0, 0,
SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserFramePosition(PRInt32 *aX, PRInt32 *aY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
RECT wndRect;
pThis->GetWindowRect(&wndRect);
if (aX)
*aX = wndRect.left;
if (aY)
*aY = wndRect.top;
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserFramePositionAndSize(PRInt32 *aX, PRInt32 *aY, PRInt32 *aCX, PRInt32 *aCY)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
RECT wndRect;
pThis->GetWindowRect(&wndRect);
if (aX)
*aX = wndRect.left;
if (aY)
*aY = wndRect.top;
if (aCX)
*aCX = wndRect.right - wndRect.left;
if (aCY)
*aCY = wndRect.bottom - wndRect.top;
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserFramePositionAndSize(PRInt32 aX, PRInt32 aY, PRInt32 aCX, PRInt32 aCY, PRBool fRepaint)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if (pThis->m_ignoreMoveResize > 0) {
pThis->m_ignoreMoveResize--;
return;
}
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
pThis->GetWindowPlacement(&wp);
if (wp.showCmd != SW_SHOWNORMAL)
return;
pThis->SetWindowPos(NULL, aX, aY, aCX, aCY,
SWP_NOACTIVATE | SWP_NOZORDER);
}
void CBrowserFrame::BrowserFrameGlueObj::SetBrowserPositionAndSize(PRInt32 aX, PRInt32 aY, PRInt32 aCX, PRInt32 aCY, PRBool fRepaint)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if (pThis->m_ignoreMoveResize > 0) {
pThis->m_ignoreMoveResize--;
return;
}
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
pThis->GetWindowPlacement(&wp);
if (wp.showCmd != SW_SHOWNORMAL)
return;
// first we have to figure out how much bigger the frame is than the view
RECT frameRect, viewRect;
pThis->GetWindowRect(&frameRect);
pThis->m_wndBrowserView.GetClientRect(&viewRect);
int deltax = (frameRect.right-frameRect.left)-(viewRect.right-viewRect.left);
int deltay = (frameRect.bottom-frameRect.top)-(viewRect.bottom-viewRect.top);
pThis->SetWindowPos(NULL, aX, aY, aCX+deltax, aCY+(deltay/2),
SWP_NOACTIVATE | SWP_NOZORDER);
}
void CBrowserFrame::BrowserFrameGlueObj::SetFocus(){
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
//if (!::IsChild(pThis->m_hWnd,::GetFocus()))
// pThis->BringWindowToTop();
pThis->m_wndBrowserView.mBaseWindow->SetFocus();
}
void CBrowserFrame::BrowserFrameGlueObj::FocusAvailable(PRBool *aFocusAvail)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
HWND focusWnd = ::GetFocus(); // GetFocus()->m_hWnd;
if ((focusWnd == pThis->m_hWnd) || ::IsChild(pThis->m_hWnd, focusWnd))
*aFocusAvail = PR_TRUE;
else
*aFocusAvail = PR_FALSE;
}
void CBrowserFrame::BrowserFrameGlueObj::ShowBrowserFrame(PRBool aShow)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
if(aShow)
{
if (pThis->m_bSizeOnLoad)
return; // Not yet, waiting for resize in UpdateBusyState
if (pThis->IsIconic())
return;
if (!pThis->IsWindowVisible()) {
if (pThis->m_created)
return;
pThis->m_created = true;
}
pThis->ShowWindow(SW_SHOW);
// pThis->SetActiveWindow();
pThis->UpdateWindow();
}
else
{
pThis->ShowWindow(SW_HIDE);
}
}
void CBrowserFrame::BrowserFrameGlueObj::GetBrowserFrameVisibility(PRBool *aVisible)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
/*// Is the current BrowserFrame the active one?
CWnd *pWnd = GetActiveWindow();
if (!pWnd || pWnd->m_hWnd != pThis->m_hWnd)
{
*aVisible = PR_FALSE;
return;
}*/
*aVisible = pThis->IsIconic() || !pThis->IsWindowVisible() ? PR_FALSE : PR_TRUE;
}
PRBool CBrowserFrame::BrowserFrameGlueObj::CreateNewBrowserFrame(PRUint32 chromeMask,
PRInt32 x, PRInt32 y,
PRInt32 cx, PRInt32 cy,
nsIWebBrowser** aWebBrowser)
{
NS_ENSURE_ARG_POINTER(aWebBrowser);
*aWebBrowser = nsnull;
CMfcEmbedApp *pApp = (CMfcEmbedApp *)AfxGetApp();
if(!pApp)
return PR_FALSE;
// Note that we're calling with the last param set to "false" i.e.
// this instructs not to show the frame window
// This is mainly needed when the window size is specified in the window.open()
// JS call. In those cases Gecko calls us to create the browser with a default
// size (all are -1) and then it calls the SizeBrowserTo() method to set
// the proper window size. If this window were to be visible then you'll see
// the window size changes on the screen causing an unappealing flicker
//
CBrowserFrame* pFrm = pApp->CreateNewBrowserFrame(chromeMask, x, y, cx, cy, PR_FALSE);
if(!pFrm)
return PR_FALSE;
// At this stage we have a new CBrowserFrame and a new CBrowserView
// objects. The CBrowserView also would have an embedded browser
// object created. Get the mWebBrowser member from the CBrowserView
// and return it. (See CBrowserView's CreateBrowser() on how the
// embedded browser gets created and how it's mWebBrowser member
// gets initialized)
NS_IF_ADDREF(*aWebBrowser = pFrm->m_wndBrowserView.mWebBrowser);
return PR_TRUE;
}
void CBrowserFrame::BrowserFrameGlueObj::DestroyBrowserFrame()
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)
pThis->PostMessage(WM_CLOSE, -1, -1);
}
void CBrowserFrame::BrowserFrameGlueObj::ShowContextMenu(PRUint32 aContextFlags, nsIContextMenuInfo *aInfo)
{
METHOD_PROLOGUE(CBrowserFrame, BrowserFrameGlueObj)