FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
Python-cefpython/src/cefpython.pyx at cefpython51 · caooliver/Python-cefpython · GitHub
caooliver
Python-cefpython
Repository navigation
Code
Pull requests
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
Python-cefpython
/
src
/
cefpython.pyx
Copy path
More file actions
More file actions
Latest commit
History
History
History
827 lines (709 loc) · 28.8 KB
Breadcrumbs
Python-cefpython
/
src
/
cefpython.pyx
Copy path
File metadata and controls
827 lines (709 loc) · 28.8 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
#
Copyright (c) 2012-2014 The CEF Python authors. All rights reserved.
#
License: New BSD License.
#
Website: http://code.google.com/p/cefpython/
"""
CHANGES in CEF since v31..v51.
Below are listed new or modified functions/classes, but not all of them.
-------------------------------------------------------------------------------
CefEnableHighDPISupport()
CefRequestContext
NEW BROWSER SETTINGS that can be get/set using request context:
* GetAllPreferences - all preferences for browser's request context
* SetPreference
* many more methods has/get/canset...
_cef_request_context_settings_t:
cache_path
persist_session_cookies
persist_user_preferences
ignore_certificate_errors
PurgePluginListCache
GetDefaultCookieManager
GetCachePath
IsSharingWith - possible to create new context that shares
storage with another context
more methods...
CefRequestContextHandler
OnBeforePluginLoad
CefBrowserSettings
windowless_frame_rate - **OSR**
CefBrowserHost
GetNavigationEntries
PrintToPDF
ParentWindowWillClose() - REMOVED, update .py examples
SetWindowVisibility()
ShowDevTools(WindowInfo, CefClient, BrowserSettings, inspect_element_at)
CloseDevTools [DONE]
ReplaceMisspelling
AddWordToDictionary
Invalidate
NotifyMoveOrResizeStarted() - call in WM_MOVE, WM_MOVING, WM_SIZING on Win
GetWindowlessFrameRate - **OSR**
SetWindowlessFrameRate - **OSR**
DragTargetDragEnter
DragTargetDragOver
DragTargetDragLeave
DragTargetDrop
DragSourceEndedAt
DragSourceSystemDragEnded
HasDevTools
DownloadImage
HasView
CefRequestHandler
OnOpenURLFromTab
OnBeforeResourceLoad - new arg CefRequestCallback
OnResourceResponse
GetResourceResponseFilter - easy way to alter response, no need for the
complicated wxpython-response.py example (Issue #229)
OnResourceLoadComplete
OnCertificateError - new args: browser and ssl_info.
No more need to set it using
cefpython.SetGlobalClientCallback()
OnRenderViewReady
Support for handling onbeforeunload in LifespanHandler::DoClose with
the use of Browser.TryCloseBrowser() or Browser.CloseBrowser.
CefRequest
SetReferrer
GetReferrerURL
GetReferrerPolicy
GetIdentifier
CefResponse
GetError
SetError
CEF exposes Views/Aura framework as an alternative API
for client applications. This can be a replacement for
WinAPI/GTK/X11/Cocoa UI frameworks. See for more info:
https://bitbucket.org/chromiumembedded/cef/issues/1749
CefPrintHandler - Linux only
CefPrintSettings
CefDisplayHandler
OnFaviconURLChange
OnFullscreenModeChange
CefRenderHandler
OnCursorChange - new args: type and custom_cursor_info
StartDragging
UpdateDragCursor
OnScrollOffsetChanged - new args: x,y
In upstream cefclient:
1. g_signal_connect(G_OBJECT(window_), "configure-event",
G_CALLBACK(&RootWindowGtk::WindowConfigure), this);
browser->GetHost()->NotifyMoveOrResizeStarted();
2. g_signal_connect(G_OBJECT(window_), "focus-in-event",
G_CALLBACK(&RootWindowGtk::WindowFocusIn), this);
self->browser_window_->SetFocus(true);
When window is minimized set browser size to 0x0 to reduce resource usage.
See cefclient:
- on Windows see https://github.com/cztomczak/phpdesktop/issues/179
- on Linux see root_window_gtk.cc > WindowState
CefContextMenuHandler
RunContextMenu
CefContextMenuParams
GetMisspelledWord
GetDictionarySuggestions
IsSpellCheckEnabled
IsCustomMenu
IsPepperMenu
CefCompletionCallback - added to many cookie functions to run asynchronously
on the IO thread
include/cef_parser.h - url/css/json/etc parsers
CefResourceBundle
CefResponseFilter
CefValue
cef_get_current_platform_thread_id()
cef_get_current_platform_thread_handle()
cef_get_xdisplay();
include/cef_ssl_info.h
include/wrapper/cef_helpers.h - CefDeleteOnThread() free object on
the specified thread
include/wrapper/cef_resource_manager.h
CefPostData
HasExcludedElements
-------------------------------------------------------------------------------
END OF: CHANGES in CEF since v31..v47.
"""
#
IMPORTANT notes:
#
#
- cdef/cpdef functions returning something other than a Python object
#
should have in its declaration "except *", otherwise exceptions are
#
ignored. Those cdef/cpdef that return "object" have "except *" by
#
default. The setup/compile.py script will check for functions missing
#
"except *" and will display an error message about that, but it's
#
not perfect and won't detect all cases.
#
#
- TODO: add checking for "except * with gil" in functions with the
#
"public" keyword
#
#
- about acquiring/releasing GIL lock, see discussion here:
#
https://groups.google.com/forum/?fromgroups=#!topic/cython-users/jcvjpSOZPp0
#
#
- <CefRefPtr[ClientHandler]?>new ClientHandler()
#
<...?> means to throw an error if the cast is not allowed
#
#
- in client handler callbacks (or others that are called from C++ and
#
use "except * with gil") must embrace all code in try..except otherwise
#
the error will be ignored, only printed to the output console, this is the
#
default behavior of Cython, to remedy this you are supposed to add "except *"
#
in function declaration, unfortunately it does not work, some conflict with
#
CEF threading, see topic at cython-users for more details:
#
https://groups.google.com/d/msg/cython-users/CRxWoX57dnM/aufW3gXMhOUJ.
#
#
- Note that acquiring the GIL is a blocking thread-synchronising operation,
#
and therefore potentially costly. It might not be worth releasing the GIL
#
for minor calculations. Usually, I/O operations and substantial
#
computations in parallel code will benefit from it.
#
#
- In regards to GIL locks see Issue #102 "Remove GIL to avoid deadlocks when
#
calling CEF functions".
#
#
- CTags requires all functions/methods imported in .pxd files to be preceded with "cdef",
#
otherwise they are not indexed.
#
#
- __del__ method does not exist in Extension Types (cdef class),
#
you have to use __dealloc__ instead, try to remember that as
#
defining __del__ will not raise any warning and could lead to
#
memory leaks.
#
#
- CefString.c_str() is safe to use only on Windows, on Ubuntu 64bit
#
for a "Pers" string it returns: "P\x00e\x00r\x00s\x00", which is
#
most probably not what you expected.
#
#
- You can rename methods when importing in pxd files:
#
| cdef cppclass _Object "Object":
#
#
- Supporting operators that are not yet supported:
#
| CefRefPtr[T]& Assign "operator="(T* p)
#
| cefBrowser.Assign(CefBrowser*)
#
In the same way you can import function with a different name, this one
#
imports a static method Create() while adding a prefix "CefSome_":
#
| cdef extern from "..":
#
| static CefRefPtr[CefSome] CefSome_Create "CefSome::Create"()
#
#
- Declaring C++ classes in Cython. Storing python callbacks
#
in a C++ class using Py_INCREF, Py_DECREF. Calling from
#
C++ using PyObject_CallMethod.
#
| http://stackoverflow.com/a/17070382/623622
#
Disadvantage: when calling python callback from the C++ class
#
declared in Cython there is no easy way to propagate the python
#
exceptions when they occur during execution of the callback.
#
#
- | cdef char* other_c_string = py_string
#
This is a very fast operation after which other_c_string points
#
to the byte string buffer of the Python string itself. It is
#
tied to the life time of the Python string. When the Python
#
string is garbage collected, the pointer becomes invalid.
#
#
- When defining cpdef functions returning "cpp_bool":
#
| cpdef cpp_bool myfunc() except *:
#
Always do an additional cast when returning value, even when
#
variable is defined as py_bool:
#
| cdef py_bool returnValue
#
| return bool(returnValue)
#
Otherwise compiler warnings appear:
#
| cefpython.cpp(26533) : warning C4800: 'int' : forcing value
#
| to bool 'true' or 'false' (performance warning)
#
Lots of these warnings results in ignoring them, but sometimes
#
they are shown for a good reason. For example when you forget
#
to return a value in a function.
#
#
- Always import bool from libcpp as cpp_bool, if you import it as
#
"bool" in a pxd file, then Cython will complain about bool casts
#
like "bool(1)" being invalid, in pyx files.
#
#
- malloc example code:
#
from libc.stdlib cimport malloc, free
#
cdef RECT* rect = <RECT*>malloc(sizeof(RECT))
#
free(rect)
#
#
All .pyx files need to be included in this file.
#
Includes being made in other .pyx files are allowed to help
#
IDE completion, but will be removed during cython compilation.
#
Version file is generated by the compile.bat/compile.py script.
include
"
__version__.pyx
"
include
"
compile_time_constants.pxi
"
#
-----------------------------------------------------------------------------
#
IMPORTS
#
noinspection PyUnresolvedReferences
import
os
import
sys
#
noinspection PyUnresolvedReferences
import
cython
#
noinspection PyUnresolvedReferences
import
platform
#
noinspection PyUnresolvedReferences
import
traceback
#
noinspection PyUnresolvedReferences
import
time
#
noinspection PyUnresolvedReferences
import
types
#
noinspection PyUnresolvedReferences
import
re
#
noinspection PyUnresolvedReferences
import
copy
#
noinspection PyUnresolvedReferences
import
inspect
#
used by JavascriptBindings.__SetObjectMethods()
#
noinspection PyUnresolvedReferences
import
urllib
#
noinspection PyUnresolvedReferences
import
json
#
noinspection PyUnresolvedReferences
import
datetime
#
noinspection PyUnresolvedReferences
import
random
if
sys.version_info.major
==
2
:
#
noinspection PyUnresolvedReferences
import
urlparse
else
:
#
noinspection PyUnresolvedReferences
from
urllib
import
parse
as
urlparse
if
sys.version_info.major
==
2
:
#
noinspection PyUnresolvedReferences
from
urllib
import
pathname2url
as
urllib_pathname2url
else
:
#
noinspection PyUnresolvedReferences
from
urllib.request
import
pathname2url
as
urllib_pathname2url
#
noinspection PyUnresolvedReferences
from
cpython.version cimport PY_MAJOR_VERSION
#
noinspection PyUnresolvedReferences
import
weakref
#
We should allow multiple string types: str, unicode, bytes.
#
PyToCefString() can handle them all.
#
Important:
#
If you set it to basestring, Cython will accept exactly(!)
#
str/unicode in Py2 and str in Py3. This won't work in Py3
#
as we might want to pass bytes as well. Also it will
#
reject string subtypes, so using it in publi API functions
#
would be a bad idea.
ctypedef
object
py_string
#
You can't use "void" along with cpdef function returning None, it is planned to be
#
added to Cython in the future, creating this virtual type temporarily. If you
#
change it later to "void" then don't forget to add "except *".
ctypedef
object
py_void
ctypedef
long
long
WindowHandle
#
noinspection PyUnresolvedReferences
from
cpython cimport PyLong_FromVoidPtr
#
noinspection PyUnresolvedReferences
from
cpython cimport
bool
as
py_bool
#
noinspection PyUnresolvedReferences
from
libcpp cimport
bool
as
cpp_bool
#
noinspection PyUnresolvedReferences
from
libcpp.map cimport
map
as
cpp_map
#
noinspection PyUnresolvedReferences
from
multimap cimport multimap
as
cpp_multimap
#
noinspection PyUnresolvedReferences
from
libcpp.pair cimport pair
as
cpp_pair
#
noinspection PyUnresolvedReferences
from
libcpp.vector cimport vector
as
cpp_vector
#
noinspection PyUnresolvedReferences
from
libcpp.string cimport string
as
cpp_string
#
noinspection PyUnresolvedReferences
from
wstring cimport wstring
as
cpp_wstring
#
noinspection PyUnresolvedReferences
from
libc.string cimport strlen
#
noinspection PyUnresolvedReferences
from
libc.string cimport memcpy
#
preincrement and dereference must be "as" otherwise not seen.
#
noinspection PyUnresolvedReferences
from
cython.operator cimport preincrement
as
preinc, dereference
as
deref
#
from cython.operator cimport address as addr # Address of an c++ object?
#
noinspection PyUnresolvedReferences
from
libc.stdlib cimport calloc, malloc, free
#
noinspection PyUnresolvedReferences
from
libc.stdlib cimport atoi
#
When pyx file cimports * from a pxd file and that pxd cimports * from another pxd
#
then these names will be visible in pyx file.
#
Circular imports are allowed in form "cimport ...", but won't work if you do
#
"from ... cimport *", this is important to know in pxd files.
#
noinspection PyUnresolvedReferences
from
libc.stdint cimport uint64_t
#
noinspection PyUnresolvedReferences
from
libc.stdint cimport uintptr_t
#
noinspection PyUnresolvedReferences
cimport ctime
IF
UNAME_SYSNAME
==
"
Windows
"
:
from
windows cimport
*
from
dpi_aware_win cimport
*
ELIF
UNAME_SYSNAME
==
"
Linux
"
:
from
linux cimport
*
ELIF
UNAME_SYSNAME
==
"
Darwin
"
:
from
mac cimport
*
from
cpp_utils cimport
*
from
task cimport
*
from
cef_string cimport
*
cdef extern
from
*
:
#
noinspection PyUnresolvedReferences
ctypedef CefString ConstCefString
"
const CefString
"
#
cannot cimport *, that would cause name conflicts with constants
#
noinspection PyUnresolvedReferences
from
cef_types cimport (
CefSettings, CefBrowserSettings, CefRect, CefPoint,
CefRequestContextSettings,
CefKeyEvent, CefMouseEvent, CefScreenInfo,
PathKey, PK_DIR_EXE, PK_DIR_MODULE
)
from
cef_task cimport
*
from
cef_platform cimport
*
from
cef_ptr cimport
*
from
cef_app cimport
*
from
cef_browser cimport
*
#
noinspection PyUnresolvedReferences
cimport cef_browser_static
from
cef_client cimport
*
from
client_handler cimport
*
from
cef_frame cimport
*
from
cef_time cimport
*
from
cef_values cimport
*
from
cefpython_app cimport
*
from
cef_process_message cimport
*
from
cef_web_plugin cimport
*
from
cef_request_handler cimport
*
from
cef_request cimport
*
from
cef_cookie cimport
*
from
cef_string_visitor cimport
*
#
noinspection PyUnresolvedReferences
cimport cef_cookie_manager_namespace
from
cookie_visitor cimport
*
from
string_visitor cimport
*
from
cef_callback cimport
*
from
cef_response cimport
*
from
cef_resource_handler cimport
*
from
resource_handler cimport
*
from
cef_urlrequest cimport
*
from
web_request_client cimport
*
from
cef_command_line cimport
*
from
cef_request_context cimport
*
from
cef_request_context_handler cimport
*
from
request_context_handler cimport
*
from
cef_jsdialog_handler cimport
*
from
cef_path_util cimport
*
#
-----------------------------------------------------------------------------
#
GLOBAL VARIABLES
g_debug
=
False
g_debugFile
=
"
debug.log
"
#
When put None here and assigned a local dictionary in Initialize(), later
#
while running app this global variable was garbage collected, see topic:
#
https://groups.google.com/d/topic/cython-users/0dw3UASh7HY/discussion
g_applicationSettings
=
{}
g_commandLineSwitches
=
{}
#
noinspection PyUnresolvedReferences
cdef cpp_bool _MessageLoopWork_wasused
=
False
cdef
dict
g_globalClientCallbacks
=
{}
#
If ApplicationSettings.unique_request_context_per_browser is False
#
then a shared request context is used for all browsers. Otherwise
#
a unique one is created for each call to CreateBrowserSync.
#
noinspection PyUnresolvedReferences
cdef CefRefPtr[CefRequestContext] g_sharedRequestContext
#
-----------------------------------------------------------------------------
include
"
utils.pyx
"
include
"
string_utils.pyx
"
IF
UNAME_SYSNAME
==
"
Windows
"
:
include
"
string_utils_win.pyx
"
include
"
time_utils.pyx
"
include
"
browser.pyx
"
include
"
frame.pyx
"
include
"
settings.pyx
"
IF
UNAME_SYSNAME
==
"
Windows
"
:
include
"
window_utils_win.pyx
"
include
"
dpi_aware_win.pyx
"
ELIF
UNAME_SYSNAME
==
"
Linux
"
:
include
"
window_utils_linux.pyx
"
ELIF
UNAME_SYSNAME
==
"
Darwin
"
:
include
"
window_utils_mac.pyx
"
include
"
task.pyx
"
include
"
javascript_bindings.pyx
"
include
"
virtual_keys.pyx
"
include
"
window_info.pyx
"
include
"
process_message_utils.pyx
"
include
"
v8context_handler.pyx
"
include
"
v8function_handler.pyx
"
include
"
javascript_callback.pyx
"
include
"
python_callback.pyx
"
include
"
lifespan_handler.pyx
"
include
"
display_handler.pyx
"
include
"
keyboard_handler.pyx
"
include
"
web_plugin_info.pyx
"
include
"
request.pyx
"
include
"
request_handler.pyx
"
include
"
cookie.pyx
"
include
"
string_visitor.pyx
"
include
"
load_handler.pyx
"
include
"
network_error.pyx
"
include
"
browser_process_handler.pyx
"
include
"
paint_buffer.pyx
"
include
"
render_handler.pyx
"
include
"
callback.pyx
"
include
"
resource_handler.pyx
"
include
"
response.pyx
"
include
"
web_request.pyx
"
include
"
command_line.pyx
"
include
"
app.pyx
"
include
"
javascript_dialog_handler.pyx
"
#
-----------------------------------------------------------------------------
#
Utility functions to provide settings to the C++ browser process code.
cdef public
void
cefpython_GetDebugOptions(
cpp_bool
*
debug,
cpp_string
*
debugFile
)
except
*
with
gil:
#
Called from subprocess/cefpython_app.cpp -> CefPythonApp constructor.
cdef cpp_string cppString
=
g_debugFile
try
:
debug[
0
]
=
<
cpp_bool
>
bool
(g_debug)
debugFile.assign(cppString)
except
:
(exc_type, exc_value, exc_trace)
=
sys.exc_info()
sys.excepthook(exc_type, exc_value, exc_trace)
cdef public cpp_bool ApplicationSettings_GetBool(const
char
*
key
)
except
*
with
gil:
#
Called from client_handler/client_handler.cpp for example
cdef py_string pyKey
=
CharToPyString(key)
if
pyKey
in
g_applicationSettings:
return
bool
(g_applicationSettings[pyKey])
return
False
cdef public cpp_bool ApplicationSettings_GetBoolFromDict(const
char
*
key1,
const
char
*
key2)
except
*
with
gil:
cdef py_string pyKey1
=
CharToPyString(key1)
cdef py_string pyKey2
=
CharToPyString(key2)
cdef
object
dictValue
#
Yet to be checked whether it is `dict`
if
pyKey1
in
g_applicationSettings:
dictValue
=
g_applicationSettings[pyKey1]
if
type
(dictValue) !
=
dict
:
return
False
if
pyKey2
in
dictValue:
return
bool
(dictValue[pyKey2])
return
False
cdef public cpp_string ApplicationSettings_GetString(const
char
*
key
)
except
*
with
gil:
cdef py_string pyKey
=
CharToPyString(key)
cdef cpp_string cppString
if
pyKey
in
g_applicationSettings:
cppString
=
AnyToPyString(g_applicationSettings[pyKey])
return
cppString
cdef public
int
CommandLineSwitches_GetInt(const
char
*
key)
except
*
with
gil:
cdef py_string pyKey
=
CharToPyString(key)
if
pyKey
in
g_commandLineSwitches:
return
int
(g_commandLineSwitches[pyKey])
return
0
#
-----------------------------------------------------------------------------
#
If you've built custom binaries with tcmalloc hook enabled on
#
Linux, then do not to run any of the CEF code until Initialize()
#
is called. See Issue #73 in the CEF Python Issue Tracker.
def
Initialize
(
applicationSettings
=
None
,
commandLineSwitches
=
None
):
#
Fix Issue #231 - Discovery of the "icudtl.dat" file fails
cdef
str
py_module_dir
=
GetModuleDirectory()
cdef CefString module_dir
PyToCefString(py_module_dir, module_dir)
CefOverridePath(PK_DIR_EXE, module_dir)\
or
Debug(
"
ERROR: CefOverridePath failed
"
)
CefOverridePath(PK_DIR_MODULE, module_dir)\
or
Debug(
"
ERROR: CefOverridePath failed
"
)
if
not
applicationSettings:
applicationSettings
=
{}
#
Debug settings need to be set before Debug() is called
#
and before the CefPythonApp class is instantiated.
global
g_debug
global
g_debugFile
if
"
debug
"
in
applicationSettings:
g_debug
=
bool
(applicationSettings[
"
debug
"
])
if
"
log_file
"
in
applicationSettings:
g_debugFile
=
applicationSettings[
"
log_file
"
]
Debug(
"
Initialize() called
"
)
#
Mac initialization. Need to call NSApplication.sharedApplication()
#
and do NSApplication methods swizzling to implement
#
CrAppControlProtocol. See Issue 156.
IF
UNAME_SYSNAME
==
"
Darwin
"
:
MacInitialize()
#
-------------------------------------------------------------------------
#
CEF Python only options - default values
if
"
debug
"
not
in
applicationSettings:
applicationSettings[
"
debug
"
]
=
False
if
"
string_encoding
"
not
in
applicationSettings:
applicationSettings[
"
string_encoding
"
]
=
"
utf-8
"
if
"
unique_request_context_per_browser
"
not
in
applicationSettings:
applicationSettings[
"
unique_request_context_per_browser
"
]
=
False
if
"
downloads_enabled
"
not
in
applicationSettings:
applicationSettings[
"
downloads_enabled
"
]
=
True
if
"
remote_debugging_port
"
not
in
applicationSettings:
applicationSettings[
"
remote_debugging_port
"
]
=
0
if
"
auto_zooming
"
not
in
applicationSettings:
IF
UNAME_SYSNAME
==
"
Windows
"
:
if
DpiAware.IsProcessDpiAware():
applicationSettings[
"
auto_zooming
"
]
=
"
system_dpi
"
#
Mouse context menu
if
"
context_menu
"
not
in
applicationSettings:
applicationSettings[
"
context_menu
"
]
=
{}
menuItems
=
[
"
enabled
"
,
"
navigation
"
,
"
print
"
,
"
view_source
"
,
"
external_browser
"
,
"
devtools
"
]
for
item
in
menuItems:
if
item
not
in
applicationSettings[
"
context_menu
"
]:
applicationSettings[
"
context_menu
"
][item]
=
True
#
Remote debugging port. If value is 0 we will generate a random
#
port. To disable remote debugging set value to -1.
if
applicationSettings[
"
remote_debugging_port
"
]
==
0
:
#
Generate a random port.
applicationSettings[
"
remote_debugging_port
"
]
=
\
random.randint(
49152
,
65535
)
elif
applicationSettings[
"
remote_debugging_port
"
]
==
-
1
:
#
Disable remote debugging
applicationSettings[
"
remote_debugging_port
"
]
=
0
#
-------------------------------------------------------------------------
#
CEF options - default values.
if
not
"
multi_threaded_message_loop
"
in
applicationSettings:
applicationSettings[
"
multi_threaded_message_loop
"
]
=
False
if
not
"
single_process
"
in
applicationSettings:
applicationSettings[
"
single_process
"
]
=
False
cdef CefRefPtr[CefApp] cefApp
=
<
CefRefPtr[CefApp]?
>
new CefPythonApp()
IF
UNAME_SYSNAME
==
"
Windows
"
:
cdef HINSTANCE hInstance
=
GetModuleHandle(
NULL
)
cdef CefMainArgs cefMainArgs
=
CefMainArgs(hInstance)
ELIF
UNAME_SYSNAME
==
"
Linux
"
:
#
TODO: use the CefMainArgs(int argc, char** argv) constructor.
cdef CefMainArgs cefMainArgs
ELIF
UNAME_SYSNAME
==
"
Darwin
"
:
#
TODO: use the CefMainArgs(int argc, char** argv) constructor.
cdef CefMainArgs cefMainArgs
cdef
int
exitCode
=
1
with
nogil:
exitCode
=
CefExecuteProcess(cefMainArgs, cefApp,
NULL
)
Debug(
"
CefExecuteProcess(): exitCode =
%s
"
%
exitCode)
if
exitCode
>=
0
:
sys.exit(exitCode)
#
Make a copy as applicationSettings is a reference only
#
that might get destroyed later.
global
g_applicationSettings
for
key
in
applicationSettings:
g_applicationSettings[key]
=
copy.deepcopy(applicationSettings[key])
cdef CefSettings cefApplicationSettings
#
No sandboxing for the subprocesses
cefApplicationSettings.no_sandbox
=
1
SetApplicationSettings(applicationSettings,
&
cefApplicationSettings)
if
commandLineSwitches:
#
Make a copy as commandLineSwitches is a reference only
#
that might get destroyed later.
global
g_commandLineSwitches
for
key
in
commandLineSwitches:
g_commandLineSwitches[key]
=
copy.deepcopy(
commandLineSwitches[key])
Debug(
"
CefInitialize()
"
)
cdef cpp_bool ret
with
nogil:
ret
=
CefInitialize(cefMainArgs, cefApplicationSettings, cefApp,
NULL
)
if
not
ret:
Debug(
"
CefInitialize() failed
"
)
return
ret
def
CreateBrowserSync
(
windowInfo
,
browserSettings
,
navigateUrl
,
requestContext
=
None
):
Debug(
"
CreateBrowserSync() called
"
)
assert
IsThread(TID_UI), (
"
cefpython.CreateBrowserSync() may only be called on the UI thread
"
)
if
not
isinstance
(windowInfo, WindowInfo):
raise
Exception
(
"
CreateBrowserSync() failed: windowInfo: invalid object
"
)
cdef CefBrowserSettings cefBrowserSettings
SetBrowserSettings(browserSettings,
&
cefBrowserSettings)
cdef CefWindowInfo cefWindowInfo
SetCefWindowInfo(cefWindowInfo, windowInfo)
navigateUrl
=
GetNavigateUrl(navigateUrl)
Debug(
"
navigateUrl:
%s
"
%
navigateUrl)
cdef CefString cefNavigateUrl
PyToCefString(navigateUrl, cefNavigateUrl)
Debug(
"
CefBrowser::CreateBrowserSync()
"
)
cdef CefRefPtr[ClientHandler] clientHandler
=
\
<
CefRefPtr[ClientHandler]?
>
new ClientHandler()
cdef CefRefPtr[CefBrowser] cefBrowser
#
Request context - part 1/2.
createSharedRequestContext
=
bool
(
not
g_sharedRequestContext.get())
cdef CefRequestContextSettings requestContextSettings
cdef CefRefPtr[CefRequestContext] cefRequestContext
cdef CefRefPtr[RequestContextHandler] requestContextHandler
=
\
<
CefRefPtr[RequestContextHandler]?
>
new RequestContextHandler(
cefBrowser)
if
g_applicationSettings[
"
unique_request_context_per_browser
"
]:
cefRequestContext
=
CefRequestContext_CreateContext(
requestContextSettings,
<
CefRefPtr[CefRequestContextHandler]?
>
requestContextHandler)
else
:
if
createSharedRequestContext:
cefRequestContext
=
CefRequestContext_CreateContext(
requestContextSettings,
<
CefRefPtr[CefRequestContextHandler]?
>
\
requestContextHandler)
g_sharedRequestContext.Assign(cefRequestContext.get())
else
:
cefRequestContext.Assign(g_sharedRequestContext.get())
#
CEF browser creation.
with
nogil:
cefBrowser
=
cef_browser_static.CreateBrowserSync(
cefWindowInfo,
<
CefRefPtr[CefClient]?
>
clientHandler,
cefNavigateUrl, cefBrowserSettings,
cefRequestContext)
if
<
void
*
>
cefBrowser
==
NULL
or
not
cefBrowser.get():
Debug(
"
CefBrowser::CreateBrowserSync() failed
"
)
return
None
else
:
Debug(
"
CefBrowser::CreateBrowserSync() succeeded
"
)
#
Request context - part 2/2.
if
g_applicationSettings[
"
unique_request_context_per_browser
"
]:
requestContextHandler.get().SetBrowser(cefBrowser)
else
:
if
createSharedRequestContext:
requestContextHandler.get().SetBrowser(cefBrowser)
cdef PyBrowser pyBrowser
=
GetPyBrowser(cefBrowser)
pyBrowser.SetUserData(
"
__outerWindowHandle
"
,
int
(windowInfo.parentWindowHandle))
return
pyBrowser
def
MessageLoop
():
Debug(
"
MessageLoop()
"
)
with
nogil:
CefRunMessageLoop()
def
MessageLoopWork
():
#
Perform a single iteration of CEF message loop processing.
#
This function is used to integrate the CEF message loop
#
into an existing application message loop.
#
Anything that can block for a significant amount of time
#
and is thread-safe should release the GIL:
#
https://groups.google.com/d/msg/cython-users/jcvjpSOZPp0/KHpUEX8IhnAJ
#
GIL must be released here otherwise we will get dead lock
#
when calling from c++ to python.
if
not
_MessageLoopWork_wasused:
global
_MessageLoopWork_wasused
_MessageLoopWork_wasused
=
True
with
nogil:
CefDoMessageLoopWork()
def
SingleMessageLoop
():
#
@deprecated, use MessageLoopWork() instead
MessageLoopWork()
def
QuitMessageLoop
():
Debug(
"
QuitMessageLoop()
"
)
with
nogil:
CefQuitMessageLoop()
def
Shutdown
():
if
g_sharedRequestContext.get():
#
A similar release is done in RemovePyBrowser and CloseBrowser.
#
This one is probably redundant. Additional testing should be done.
Debug(
"
Shutdown: releasing shared request context
"
)
g_sharedRequestContext.Assign(
NULL
)
Debug(
"
Shutdown()
"
)
with
nogil:
#
Temporary fix for possible errors on shutdown. See this post:
#
https://magpcss.org/ceforum/viewtopic.php?p=30858#p30858
#
May be fixed by host owned message loop, see Issue 1805:
#
https://bitbucket.org/chromiumembedded/cef/issues/1805/
if
_MessageLoopWork_wasused:
for
i
in
range
(
10
):
CefDoMessageLoopWork()
CefShutdown()
if
_MessageLoopWork_wasused:
for
i
in
range
(
10
):
CefDoMessageLoopWork()
def
SetOsModalLoop
(py_bool
modalLoop
):
cdef cpp_bool cefModalLoop
=
bool
(modalLoop)
with
nogil:
CefSetOSModalLoop(cefModalLoop)
cpdef py_void SetGlobalClientCallback(py_string name,
object
callback):
global
g_globalClientCallbacks
if
name
in
[
"
OnCertificateError
"
,
"
OnBeforePluginLoad
"
,
"
OnAfterCreated
"
]:
g_globalClientCallbacks[name]
=
callback
else
:
raise
Exception
(
"
SetGlobalClientCallback() failed:
"
\
"
invalid callback name =
%s
"
%
name)
cpdef
object
GetGlobalClientCallback(py_string name):
global
g_globalClientCallbacks
if
name
in
g_globalClientCallbacks:
return
g_globalClientCallbacks[name]
else
:
return
None
Back
|
FazBrowse Home
|
New Git URL