A: view's component events/procs

cef/internal/def/proc-def-index.go

@@ -2415,4 +2415,16 @@ const (
 	BrowserViewDelegate_SetOnGetDelegateForPopupBrowserView
 	BrowserViewDelegate_SetOnPopupBrowserViewCreated
 	BrowserViewDelegate_GetChromeToolbarType
+	// ICefButton
+	Button_AsLabelButton
+	Button_SetState
+	Button_GetState
+	Button_SetInkDropEnabled
+	Button_SetTooltipText
+	Button_SetAccessibleName
+	// ICefButtonDelegate
+	ButtonDelegateRef_Create
+	ButtonDelegateRef_CreateForCustom
+	ButtonDelegate_SetOnButtonPressed
+	ButtonDelegate_SetOnButtonStateChanged
 ) //end

cef/internal/def/proc-def.go

@@ -2415,6 +2415,18 @@ func init() {
 		dllimports.NewEnergyImport("BrowserViewDelegate_SetOnGetDelegateForPopupBrowserView", 0),
 		dllimports.NewEnergyImport("BrowserViewDelegate_SetOnPopupBrowserViewCreated", 0),
 		dllimports.NewEnergyImport("BrowserViewDelegate_GetChromeToolbarType", 0),
+		// ICefButton
+		dllimports.NewEnergyImport("Button_AsLabelButton", 0),
+		dllimports.NewEnergyImport("Button_SetState", 0),
+		dllimports.NewEnergyImport("Button_GetState", 0),
+		dllimports.NewEnergyImport("Button_SetInkDropEnabled", 0),
+		dllimports.NewEnergyImport("Button_SetTooltipText", 0),
+		dllimports.NewEnergyImport("Button_SetAccessibleName", 0),
+		// ICefButtonDelegate
+		dllimports.NewEnergyImport("ButtonDelegateRef_Create", 0),
+		dllimports.NewEnergyImport("ButtonDelegateRef_CreateForCustom", 0),
+		dllimports.NewEnergyImport("ButtonDelegate_SetOnButtonPressed", 0),
+		dllimports.NewEnergyImport("ButtonDelegate_SetOnButtonStateChanged", 0),
 	} //end
 	imports.SetEnergyImportDefs(energyImportDefs)
 }

cef/types-button-component.go

@@ -95,8 +95,8 @@ func (m *TCEFButtonComponent) SetOnButtonStateChanged(fn onButtonStateChanged) {
 	imports.Proc(def.ButtonComponent_SetOnButtonStateChanged).Call(m.Instance(), api.MakeEventDataPtr(fn))
 }
 
-type onButtonPressed func(sender lcl.IObject, button *ICefButton)
-type onButtonStateChanged func(sender lcl.IObject, button *ICefButton)
+type onButtonPressed func(button *ICefButton)
+type onButtonStateChanged func(button *ICefButton)
 
 func init() {
 	lcl.RegisterExtEventCallback(func(fn interface{}, getVal func(idx int) uintptr) bool {
@@ -105,11 +105,11 @@ func init() {
 		}
 		switch fn.(type) {
 		case onButtonPressed:
-			button := (*ICefButton)(getPtr(1))
-			fn.(onButtonPressed)(lcl.AsObject(getPtr(0)), button)
+			button := (*ICefButton)(getPtr(0))
+			fn.(onButtonPressed)(button)
 		case onButtonStateChanged:
-			button := (*ICefButton)(getPtr(1))
-			fn.(onButtonStateChanged)(lcl.AsObject(getPtr(0)), button)
+			button := (*ICefButton)(getPtr(0))
+			fn.(onButtonStateChanged)(button)
 		default:
 			return false
 		}

cef/types-button-delegate.go

+//----------------------------------------
+//
+// Copyright © yanghy. All Rights Reserved.
+//
+// Licensed under Apache License Version 2.0, January 2004
+//
+// https//www.apache.org/licenses/LICENSE-2.0
+//
+//----------------------------------------
+
+package cef
+
+import (
+	"github.com/energye/energy/v2/cef/internal/def"
+	"github.com/energye/energy/v2/common/imports"
+	"github.com/energye/energy/v2/consts"
+	"github.com/energye/golcl/lcl/api"
+	"unsafe"
+)
+
+// ButtonDelegateRef -> TCEFButtonDelegate
+var ButtonDelegateRef buttonDelegate
+
+type buttonDelegate uintptr
+
+func (*buttonDelegate) New() *ICefButtonDelegate {
+	var result uintptr
+	imports.Proc(def.ButtonDelegateRef_Create).Call(uintptr(unsafe.Pointer(&result)))
+	if result != 0 {
+		return &ICefButtonDelegate{&ICefViewDelegate{instance: getInstance(result)}}
+	}
+	return nil
+}
+
+func (*buttonDelegate) NewForCustom(buttonComponent *TCEFButtonComponent) *ICefButtonDelegate {
+	if !buttonComponent.IsValid() {
+		return nil
+	}
+	var result uintptr
+	imports.Proc(def.ButtonDelegateRef_CreateForCustom).Call(buttonComponent.Instance(), uintptr(unsafe.Pointer(&result)))
+	if result != 0 {
+		return &ICefButtonDelegate{&ICefViewDelegate{instance: getInstance(result), ct: consts.CtOther}}
+	}
+	return nil
+}
+
+func (m *ICefButtonDelegate) SetOnButtonPressed(fn onButtonPressed) {
+	if !m.IsValid() || m.IsOtherEvent() {
+		return
+	}
+	imports.Proc(def.ButtonDelegate_SetOnButtonPressed).Call(m.Instance(), api.MakeEventDataPtr(fn))
+}
+
+func (m *ICefButtonDelegate) SetOnButtonStateChanged(fn onButtonStateChanged) {
+	if !m.IsValid() || m.IsOtherEvent() {
+		return
+	}
+	imports.Proc(def.ButtonDelegate_SetOnButtonStateChanged).Call(m.Instance(), api.MakeEventDataPtr(fn))
+}

cef/types-button.go

@@ -9,3 +9,59 @@
 //----------------------------------------
 
 package cef
+
+import (
+	"github.com/energye/energy/v2/cef/internal/def"
+	"github.com/energye/energy/v2/common/imports"
+	"github.com/energye/energy/v2/consts"
+	"github.com/energye/golcl/lcl/api"
+	"unsafe"
+)
+
+func (m *ICefButton) AsLabelButton() *ICefLabelButton {
+	if !m.IsValid() {
+		return nil
+	}
+	var result uintptr
+	imports.Proc(def.Button_AsLabelButton).Call(m.Instance(), uintptr(unsafe.Pointer(&result)))
+	if result != 0 {
+		return &ICefLabelButton{&ICefButton{&ICefView{instance: getInstance(result)}}}
+	}
+	return nil
+}
+
+func (m *ICefButton) SetState(state consts.TCefButtonState) {
+	if !m.IsValid() {
+		return
+	}
+	imports.Proc(def.Button_SetState).Call(m.Instance(), uintptr(state))
+}
+
+func (m *ICefButton) GetState() consts.TCefButtonState {
+	if !m.IsValid() {
+		return 0
+	}
+	r1, _, _ := imports.Proc(def.Button_GetState).Call(m.Instance())
+	return consts.TCefButtonState(r1)
+}
+
+func (m *ICefButton) SetInkDropEnabled(enabled bool) {
+	if !m.IsValid() {
+		return
+	}
+	imports.Proc(def.Button_SetInkDropEnabled).Call(m.Instance(), api.PascalBool(enabled))
+}
+
+func (m *ICefButton) SetTooltipText(tooltipText string) {
+	if !m.IsValid() {
+		return
+	}
+	imports.Proc(def.Button_SetTooltipText).Call(m.Instance(), api.PascalStr(tooltipText))
+}
+
+func (m *ICefButton) SetAccessibleName(name string) {
+	if !m.IsValid() {
+		return
+	}
+	imports.Proc(def.Button_SetAccessibleName).Call(m.Instance(), api.PascalStr(name))
+}

cef/types-view-delegate.go

@@ -163,45 +163,45 @@ func init() {
 		}
 		switch fn.(type) {
 		case onGetPreferredSize:
-			view := &ICefView{instance: getPtr(1)}
-			resultSize := (*TCefSize)(getPtr(2))
+			view := &ICefView{instance: getPtr(0)}
+			resultSize := (*TCefSize)(getPtr(1))
 			fn.(onGetPreferredSize)(view, resultSize)
 		case onGetMinimumSize:
-			view := &ICefView{instance: getPtr(1)}
-			resultSize := (*TCefSize)(getPtr(2))
+			view := &ICefView{instance: getPtr(0)}
+			resultSize := (*TCefSize)(getPtr(1))
 			fn.(onGetMinimumSize)(view, resultSize)
 		case onGetMaximumSize:
-			view := &ICefView{instance: getPtr(1)}
-			resultSize := (*TCefSize)(getPtr(2))
+			view := &ICefView{instance: getPtr(0)}
+			resultSize := (*TCefSize)(getPtr(1))
 			fn.(onGetMaximumSize)(view, resultSize)
 		case onGetHeightForWidth:
-			view := &ICefView{instance: getPtr(1)}
-			width := int32(getVal(2))
-			resultPtr := (*int32)(getPtr(3))
+			view := &ICefView{instance: getPtr(0)}
+			width := int32(getVal(1))
+			resultPtr := (*int32)(getPtr(2))
 			*resultPtr = fn.(onGetHeightForWidth)(view, width)
 		case onParentViewChanged:
-			view := &ICefView{instance: getPtr(1)}
-			added := api.GoBool(getVal(2))
-			parent := &ICefView{instance: getPtr(3)}
+			view := &ICefView{instance: getPtr(0)}
+			added := api.GoBool(getVal(1))
+			parent := &ICefView{instance: getPtr(2)}
 			fn.(onParentViewChanged)(view, added, parent)
 		case onChildViewChanged:
-			view := &ICefView{instance: getPtr(1)}
-			added := api.GoBool(getVal(2))
-			child := &ICefView{instance: getPtr(3)}
+			view := &ICefView{instance: getPtr(0)}
+			added := api.GoBool(getVal(1))
+			child := &ICefView{instance: getPtr(2)}
 			fn.(onChildViewChanged)(view, added, child)
 		case onWindowChanged:
-			view := &ICefView{instance: getPtr(1)}
-			added := api.GoBool(getVal(2))
+			view := &ICefView{instance: getPtr(0)}
+			added := api.GoBool(getVal(1))
 			fn.(onWindowChanged)(view, added)
 		case onLayoutChanged:
-			view := &ICefView{instance: getPtr(1)}
-			newBounds := (*TCefRect)(getPtr(2))
+			view := &ICefView{instance: getPtr(0)}
+			newBounds := (*TCefRect)(getPtr(1))
 			fn.(onLayoutChanged)(view, newBounds)
 		case onFocus:
-			view := &ICefView{instance: getPtr(1)}
+			view := &ICefView{instance: getPtr(0)}
 			fn.(onFocus)(view)
 		case onBlur:
-			view := &ICefView{instance: getPtr(1)}
+			view := &ICefView{instance: getPtr(0)}
 			fn.(onBlur)(view)
 		default:
 			return false

cef/types.go

@@ -531,6 +531,11 @@ type ICefBrowserViewDelegate struct {
 	*ICefViewDelegate
 }
 
+// ICefButtonDelegate
+type ICefButtonDelegate struct {
+	*ICefViewDelegate
+}
+
 // TCEFViewComponent
 type TCEFViewComponent struct {
 	instance unsafe.Pointer

consts/consts.go

@@ -1132,12 +1132,12 @@ const (
 
 // CefCreateType
 //	CtSelfOwn 自己处理事件
-//	CtOther   使用其他处理事件
+//	CtOther   使用其他组件处理事件
 type CefCreateType = types.Int8
 
 const (
 	CtSelfOwn CefCreateType = iota // CtSelfOwn 自己处理事件
-	CtOther                        // CtOther   使用其他处理事件
+	CtOther                        // CtOther   使用其他组件处理事件
 )
 
 // /include/internal/cef_types.h (cef_quick_menu_edit_state_flags_t)