func Invoke(this *ole.IDispatch, dispid int, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr { switch dispid { case 0: log.Println("DataArrival") winsock := (*EventReceiver)(unsafe.Pointer(this)).host var data ole.VARIANT ole.VariantInit(&data) oleutil.CallMethod(winsock, "GetData", &data) s := string(data.ToArray().ToByteArray()) println() println(s) println() case 1: log.Println("Connected") winsock := (*EventReceiver)(unsafe.Pointer(this)).host oleutil.CallMethod(winsock, "SendData", "GET / HTTP/1.0\r\n\r\n") case 3: log.Println("SendProgress") case 4: log.Println("SendComplete") case 5: log.Println("Close") this.Release() case 6: log.Fatal("Error") default: log.Println(dispid) } return ole.E_NOTIMPL }
func getFriendlyName(portname string) string { // this method panics a lot and i'm not sure why, just catch // the panic and return empty list defer func() { if e := recover(); e != nil { // e is the interface{} typed-value we passed to panic() log.Println("Got panic: ", e) // Prints "Whoops: boom!" } }() var friendlyName string // init COM, oh yeah ole.CoInitialize(0) defer ole.CoUninitialize() unknown, _ := oleutil.CreateObject("WbemScripting.SWbemLocator") defer unknown.Release() wmi, _ := unknown.QueryInterface(ole.IID_IDispatch) defer wmi.Release() // service is a SWbemServices serviceRaw, _ := oleutil.CallMethod(wmi, "ConnectServer") service := serviceRaw.ToIDispatch() defer service.Release() // result is a SWBemObjectSet //pname := syscall.StringToUTF16("SELECT * FROM Win32_PnPEntity where Name like '%" + "COM35" + "%'") pname := "SELECT * FROM Win32_PnPEntity where Name like '%" + portname + "%'" resultRaw, _ := oleutil.CallMethod(service, "ExecQuery", pname) result := resultRaw.ToIDispatch() defer result.Release() countVar, _ := oleutil.GetProperty(result, "Count") count := int(countVar.Val) for i := 0; i < count; i++ { // item is a SWbemObject, but really a Win32_Process itemRaw, _ := oleutil.CallMethod(result, "ItemIndex", i) item := itemRaw.ToIDispatch() defer item.Release() asString, _ := oleutil.GetProperty(item, "Name") println(asString.ToString()) friendlyName = asString.ToString() } return friendlyName }
func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Agent.Control.1") agent, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(agent, "Connected", true) characters := oleutil.MustGetProperty(agent, "Characters").ToIDispatch() oleutil.CallMethod(characters, "Load", "Merlin", "c:\\windows\\msagent\\chars\\Merlin.acs") character := oleutil.MustCallMethod(characters, "Character", "Merlin").ToIDispatch() oleutil.CallMethod(character, "Show") oleutil.CallMethod(character, "Speak", "こんにちわ世界") time.Sleep(4000000000) }
func (tx *AdodbTx) Commit() error { _, err := oleutil.CallMethod(tx.c.db, "CommitTrans") if err != nil { return err } return nil }
func (rc *AdodbRows) Close() error { _, err := oleutil.CallMethod(rc.rc, "Close") if err != nil { return err } return nil }
func main() { ole.CoInitialize(0) unknown, err := oleutil.CreateObject("{248DD896-BB45-11CF-9ABC-0080C7E7B78D}") if err != nil { panic(err.Error()) } winsock, _ := unknown.QueryInterface(ole.IID_IDispatch) iid, _ := ole.CLSIDFromString("{248DD893-BB45-11CF-9ABC-0080C7E7B78D}") dest := &EventReceiver{} dest.lpVtbl = &EventReceiverVtbl{} dest.lpVtbl.pQueryInterface = syscall.NewCallback(QueryInterface) dest.lpVtbl.pAddRef = syscall.NewCallback(AddRef) dest.lpVtbl.pRelease = syscall.NewCallback(Release) dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(GetTypeInfoCount) dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(GetTypeInfo) dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(GetIDsOfNames) dest.lpVtbl.pInvoke = syscall.NewCallback(Invoke) dest.host = winsock oleutil.ConnectObject(winsock, iid, (*ole.IUnknown)(unsafe.Pointer(dest))) _, err = oleutil.CallMethod(winsock, "Connect", "127.0.0.1", 80) if err != nil { log.Fatal(err) } var m ole.Msg for dest.ref != 0 { ole.GetMessage(&m, 0, 0, 0) ole.DispatchMessage(&m) } }
func (c *AdodbConn) begin(ctx context.Context) (driver.Tx, error) { _, err := oleutil.CallMethod(c.db, "BeginTrans") if err != nil { return nil, err } return &AdodbTx{c}, nil }
func readExample(fileName string, excel, workbooks *ole.IDispatch) { workbook, err := oleutil.CallMethod(workbooks, "Open", fileName) if err != nil { log.Fatalln(err) } defer workbook.ToIDispatch().Release() sheets := oleutil.MustGetProperty(excel, "Sheets").ToIDispatch() sheetCount := (int)(oleutil.MustGetProperty(sheets, "Count").Val) fmt.Println("sheet count=", sheetCount) sheets.Release() worksheet := oleutil.MustGetProperty(workbook.ToIDispatch(), "Worksheets", 1).ToIDispatch() defer worksheet.Release() for row := 1; row <= 2; row++ { for col := 1; col <= 5; col++ { cell := oleutil.MustGetProperty(worksheet, "Cells", row, col).ToIDispatch() val, err := oleutil.GetProperty(cell, "Value") if err != nil { break } fmt.Printf("(%d,%d)=%+v toString=%s\n", col, row, val.Value(), val.ToString()) cell.Release() } } }
func (tx *AdodbTx) Rollback() error { _, err := oleutil.CallMethod(tx.c.db, "Rollback") if err != nil { return err } return nil }
func (c *AdodbConn) Close() error { _, err := oleutil.CallMethod(c.db, "Close") if err != nil { return err } c.db = nil ole.CoUninitialize() return nil }
func main() { cwd, _ := os.Getwd() artworkjpg := filepath.Join(cwd, "artwork.jpg") gc := gntp.NewClient() gc.AppName = "nowplaying" gc.Register([]gntp.Notification{{"default", "", true}}) ole.CoInitialize(0) unk, err := oleutil.CreateObject("iTunes.Application") if err != nil { log.Fatal(err) } unk.AddRef() dsp := unk.MustQueryInterface(ole.IID_IDispatch) prev := "" for { func() { defer func() { recover() }() track := oleutil.MustGetProperty(dsp, "CurrentTrack").ToIDispatch() if track != nil { name := oleutil.MustGetProperty(track, "Name").ToString() artist := oleutil.MustGetProperty(track, "artist").ToString() album := oleutil.MustGetProperty(track, "Album").ToString() curr := fmt.Sprintf("%s/%s\n%s", name, artist, album) if curr != prev { prev = curr artwork := oleutil.MustGetProperty(track, "Artwork").ToIDispatch() item := oleutil.MustGetProperty(artwork, "Item", 1).ToIDispatch() icon := "" if item != nil { _, err = oleutil.CallMethod(item, "SaveArtworkToFile", artworkjpg) if err != nil { log.Print(err) } else { icon = artworkjpg } } log.Print(curr) err = gc.Notify(&gntp.Message{ Event: "default", Title: "iTunes", Text: curr, Icon: icon, }) if err != nil { log.Print(err) } } } }() time.Sleep(3 * time.Second) } }
func (s *AdodbStmt) bind(args []namedValue) error { if s.b != nil { for i, v := range args { var b string = "?" if len(s.b) < i { b = s.b[i] } unknown, err := oleutil.CallMethod(s.s, "CreateParameter", b, 12, 1) if err != nil { return err } param := unknown.ToIDispatch() defer param.Release() _, err = oleutil.PutProperty(param, "Value", v.Value) if err != nil { return err } _, err = oleutil.CallMethod(s.ps, "Append", param) if err != nil { return err } } } else { for i, v := range args { var err error var val *ole.VARIANT if v.Name != "" { val, err = oleutil.CallMethod(s.ps, "Item", v.Name) } else { val, err = oleutil.CallMethod(s.ps, "Item", int32(i)) } if err != nil { return err } item := val.ToIDispatch() defer item.Release() _, err = oleutil.PutProperty(item, "Value", v.Value) if err != nil { return err } } } return nil }
func (s *AdodbStmt) query(ctx context.Context, args []namedValue) (driver.Rows, error) { if err := s.bind(args); err != nil { return nil, err } rc, err := oleutil.CallMethod(s.s, "Execute") if err != nil { return nil, err } return &AdodbRows{s, rc.ToIDispatch(), -1, nil}, nil }
func (s *AdodbStmt) exec(ctx context.Context, args []namedValue) (driver.Result, error) { if err := s.bind(args); err != nil { return nil, err } _, err := oleutil.CallMethod(s.s, "Execute") if err != nil { return nil, err } return driver.ResultNoRows, nil }
func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Excel.Application") excel, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.PutProperty(excel, "Visible", true) workbooks := oleutil.MustGetProperty(excel, "Workbooks").ToIDispatch() workbook := oleutil.MustCallMethod(workbooks, "Add", nil).ToIDispatch() worksheet := oleutil.MustGetProperty(workbook, "Worksheets", 1).ToIDispatch() cell := oleutil.MustGetProperty(worksheet, "Cells", 1, 1).ToIDispatch() oleutil.PutProperty(cell, "Value", 12345) time.Sleep(2000000000) oleutil.PutProperty(workbook, "Saved", true) oleutil.CallMethod(workbook, "Close", false) oleutil.CallMethod(excel, "Quit") excel.Release() ole.CoUninitialize() }
func (mso *MSO) AddSheet(wb *ole.IDispatch, args ...string) (Sheet, error) { sheets := oleutil.MustGetProperty(wb, "Sheets").ToIDispatch() defer sheets.Release() _sheet, err := oleutil.CallMethod(sheets, "Add") sheet := Sheet{_sheet.ToIDispatch()} if args != nil { sheet.Name(args...) } sheet.Select() return sheet, err }
func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("Microsoft.XMLHTTP") xmlhttp, _ := unknown.QueryInterface(ole.IID_IDispatch) _, err := oleutil.CallMethod(xmlhttp, "open", "GET", "http://rss.slashdot.org/Slashdot/slashdot", false) if err != nil { panic(err.Error()) } _, err = oleutil.CallMethod(xmlhttp, "send", nil) if err != nil { panic(err.Error()) } state := -1 for state != 4 { state = int(oleutil.MustGetProperty(xmlhttp, "readyState").Val) time.Sleep(10000000) } responseXml := oleutil.MustGetProperty(xmlhttp, "responseXml").ToIDispatch() items := oleutil.MustCallMethod(responseXml, "selectNodes", "/rss/channel/item").ToIDispatch() length := int(oleutil.MustGetProperty(items, "length").Val) for n := 0; n < length; n++ { item := oleutil.MustGetProperty(items, "item", n).ToIDispatch() title := oleutil.MustCallMethod(item, "selectSingleNode", "title").ToIDispatch() fmt.Println(oleutil.MustGetProperty(title, "text").ToString()) link := oleutil.MustCallMethod(item, "selectSingleNode", "link").ToIDispatch() fmt.Println(" " + oleutil.MustGetProperty(link, "text").ToString()) title.Release() link.Release() item.Release() } items.Release() xmlhttp.Release() }
func createMdb(f string) error { unk, err := oleutil.CreateObject("ADOX.Catalog") if err != nil { return err } cat, err := unk.QueryInterface(ole.IID_IDispatch) if err != nil { return err } _, err = oleutil.CallMethod(cat, "Create", "Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+f+";") if err != nil { return err } return nil }
func (s *AdodbStmt) NumInput() int { if s.b != nil { return len(s.b) } _, err := oleutil.CallMethod(s.ps, "Refresh") if err != nil { return -1 } val, err := oleutil.GetProperty(s.ps, "Count") if err != nil { return -1 } c := int(val.Val) return c }
func (d *AdodbDriver) Open(dsn string) (driver.Conn, error) { ole.CoInitialize(0) unknown, err := oleutil.CreateObject("ADODB.Connection") if err != nil { return nil, err } db, err := unknown.QueryInterface(ole.IID_IDispatch) if err != nil { return nil, err } _, err = oleutil.CallMethod(db, "Open", dsn) if err != nil { return nil, err } return &AdodbConn{db}, nil }
func (wb WorkBook) SaveAs(args ...interface{}) (err error) { defer Except("WorkBook.SaveAs", &err) if len(args) > 1 { switch args[1].(type) { case string: ffs := strings.ToLower(args[1].(string)) if n, ok := wb.FILEFORMAT[ffs]; ok { fn := args[0].(string) if !strings.HasSuffix(fn, "."+ffs) { args[0] = fn + "." + ffs } args[1] = n } else { args[1] = nil } } } _, err = oleutil.CallMethod(wb.Idisp, "SaveAs", args...) return }
func main() { command := &commander.Command{ UsageLine: os.Args[0], Short: "itunes cmd", } command.Subcommands = []*commander.Command{} for _, name := range []string{"Play", "Stop", "Pause", "Quit"} { command.Subcommands = append(command.Subcommands, &commander.Command{ Run: func(cmd *commander.Command, args []string) error { _, err := oleutil.CallMethod(iTunes(), name) return err }, UsageLine: strings.ToLower(name), }) } err := command.Dispatch(os.Args[1:]) if err != nil { log.Fatal(err) } }
func main() { ole.CoInitialize(0) unknown, _ := oleutil.CreateObject("InternetExplorer.Application") ie, _ := unknown.QueryInterface(ole.IID_IDispatch) oleutil.CallMethod(ie, "Navigate", "http://www.google.com") oleutil.PutProperty(ie, "Visible", true) for { if oleutil.MustGetProperty(ie, "Busy").Val == 0 { break } } time.Sleep(1e9) document := oleutil.MustGetProperty(ie, "document").ToIDispatch() window := oleutil.MustGetProperty(document, "parentWindow").ToIDispatch() // set 'golang' to text box. oleutil.MustCallMethod(window, "eval", "document.getElementsByName('q')[0].value = 'golang'") // click btnG. btnG := oleutil.MustCallMethod(window, "eval", "document.getElementsByName('btnG')[0]").ToIDispatch() oleutil.MustCallMethod(btnG, "click") }
func (rc *AdodbRows) Columns() []string { if rc.nc != len(rc.cols) { unknown, err := oleutil.GetProperty(rc.rc, "Fields") if err != nil { return []string{} } fields := unknown.ToIDispatch() defer fields.Release() val, err := oleutil.GetProperty(fields, "Count") if err != nil { return []string{} } rc.nc = int(val.Val) rc.cols = make([]string, rc.nc) for i := 0; i < rc.nc; i++ { var varval ole.VARIANT varval.VT = ole.VT_I4 varval.Val = int64(i) val, err := oleutil.CallMethod(fields, "Item", &varval) if err != nil { return []string{} } item := val.ToIDispatch() if err != nil { return []string{} } name, err := oleutil.GetProperty(item, "Name") if err != nil { return []string{} } rc.cols[i] = name.ToString() item.Release() } } return rc.cols }
// NOTE: This function will panic if called with high frequency (we should throttle the polling - probably caused by slow OLE calls that can't be parallel.. sigh ;)) func GetSerialPortList() ([]CommPort, error) { err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED) if err != nil { log.Fatal("Init error: ", err) } defer ole.CoUninitialize() unknown, _ := oleutil.CreateObject("WbemScripting.SWbemLocator") defer unknown.Release() wmi, _ := unknown.QueryInterface(ole.IID_IDispatch) defer wmi.Release() serviceRaw, _ := oleutil.CallMethod(wmi, "ConnectServer") service := serviceRaw.ToIDispatch() defer service.Release() query := "SELECT * FROM Win32_PnPEntity WHERE ConfigManagerErrorCode = 0 and Name like '%(COM%'" queryResult, err2 := oleutil.CallMethod(service, "ExecQuery", query) commPorts := []CommPort{} if err2 != nil { log.Printf("Error from oleutil.CallMethod: ", err2) return nil, err2 } result := queryResult.ToIDispatch() defer result.Release() countVar, _ := oleutil.GetProperty(result, "Count") count := int(countVar.Val) // Should we filter on VID/PID here or later? for i := 0; i < count; i++ { itemRaw, _ := oleutil.CallMethod(result, "ItemIndex", i) item := itemRaw.ToIDispatch() defer item.Release() displayName, _ := oleutil.GetProperty(item, "Name") fmt.Printf("Port found: %s\n", displayName.ToString()) re := regexp.MustCompile("\\((COM[0-9]+)\\)").FindAllStringSubmatch(displayName.ToString(), 1) var path string = "" if re != nil && len(re[0]) > 1 { path = re[0][1] } fmt.Printf("Path: %v\n", path) deviceId, _ := oleutil.GetProperty(item, "DeviceID") re = regexp.MustCompile("ID_(....)").FindAllStringSubmatch(deviceId.ToString(), 2) var VID, PID uint16 = 0, 0 if re != nil && len(re) == 2 { if len(re[0]) > 1 { val, _ := strconv.ParseUint(re[0][1], 16, 16) VID = uint16(val) } if len(re[1]) > 1 { val, _ := strconv.ParseUint(re[1][1], 16, 16) PID = uint16(val) } fmt.Printf("VID: %v, PID: %v\n", VID, PID) } commPorts = append(commPorts, CommPort{Path: path, VendorId: VID, ProductId: PID, DisplayName: displayName.ToString()}) } return commPorts, err }
func listComPorts() { // init COM ole.CoInitialize(0) defer ole.CoUninitialize() locator, err := oleutil.CreateObject("WbemScripting.SWbemLocator") if err != nil { log.Fatal(err) } defer locator.Release() wmi, err := locator.QueryInterface(ole.IID_IDispatch) if err != nil { log.Fatal(err) } defer wmi.Release() // service is a SWbemServices serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer") if err != nil { log.Fatal(err) } service := serviceRaw.ToIDispatch() defer service.Release() // result is a SWBemObjectSet resultRaw, err := oleutil.CallMethod(service, "ExecQuery", "SELECT * FROM Win32_PnPEntity WHERE Name LIKE '%(COM%)'") if err != nil { log.Fatal(err) } result := resultRaw.ToIDispatch() defer result.Release() countVar, err := oleutil.GetProperty(result, "Count") if err != nil { log.Fatal(err) } count := int(countVar.Val) var ports Ports re := regexp.MustCompile(`(.*) \(COM(\d+)\)$`) for i := 0; i < count; i++ { // item is a SWbemObject, but really a Win32_Process itemRaw, err := oleutil.CallMethod(result, "ItemIndex", i) if err != nil { continue } item := itemRaw.ToIDispatch() defer item.Release() property, err := oleutil.GetProperty(item, "Name") if err != nil { continue } port := re.FindAllStringSubmatch(property.ToString(), -1) num, _ := strconv.Atoi(port[0][2]) ports = append(ports, Port{num, port[0][1]}) } sort.Sort(ports) digit := getDigit(ports[len(ports)-1].Number) for i := 0; i < len(ports); i++ { fmt.Println("COM" + strconv.Itoa(ports[i].Number) + strings.Repeat(" ", digit-getDigit(ports[i].Number)) + " : " + ports[i].Name) } }
func getListViaWmiPnpEntity() ([]OsSerialPort, os.SyscallError) { //log.Println("Doing getListViaWmiPnpEntity()") // this method panics a lot and i'm not sure why, just catch // the panic and return empty list defer func() { if e := recover(); e != nil { // e is the interface{} typed-value we passed to panic() log.Println("Got panic: ", e) // Prints "Whoops: boom!" } }() var err os.SyscallError //var friendlyName string // init COM, oh yeah ole.CoInitialize(0) defer ole.CoUninitialize() unknown, _ := oleutil.CreateObject("WbemScripting.SWbemLocator") defer unknown.Release() wmi, _ := unknown.QueryInterface(ole.IID_IDispatch) defer wmi.Release() // service is a SWbemServices serviceRaw, _ := oleutil.CallMethod(wmi, "ConnectServer") service := serviceRaw.ToIDispatch() defer service.Release() // result is a SWBemObjectSet //pname := syscall.StringToUTF16("SELECT * FROM Win32_PnPEntity where Name like '%" + "COM35" + "%'") pname := "SELECT * FROM Win32_PnPEntity WHERE ConfigManagerErrorCode = 0 and Name like '%(COM%'" //pname := "SELECT * FROM Win32_PnPEntity WHERE ConfigManagerErrorCode = 0" resultRaw, err2 := oleutil.CallMethod(service, "ExecQuery", pname) //log.Println("Got result from oleutil.CallMethod") if err2 != nil { // we got back an error or empty list log.Printf("Got an error back from oleutil.CallMethod. err:%v", err2) return nil, err } result := resultRaw.ToIDispatch() defer result.Release() countVar, _ := oleutil.GetProperty(result, "Count") count := int(countVar.Val) list := make([]OsSerialPort, count) for i := 0; i < count; i++ { // items we're looping thru look like below and // thus we can query for any of these names /* __GENUS : 2 __CLASS : Win32_PnPEntity __SUPERCLASS : CIM_LogicalDevice __DYNASTY : CIM_ManagedSystemElement __RELPATH : Win32_PnPEntity.DeviceID="USB\\VID_1D50&PID_606D&MI_02\\6&2F09EA14&0&0002" __PROPERTY_COUNT : 24 __DERIVATION : {CIM_LogicalDevice, CIM_LogicalElement, CIM_ManagedSystemElement} __SERVER : JOHN-ATIV __NAMESPACE : root\cimv2 __PATH : \\JOHN-ATIV\root\cimv2:Win32_PnPEntity.DeviceID="USB\\VID_1D50&PID_606D&MI_02\\6&2F09EA14 &0&0002" Availability : Caption : TinyG v2 (Data Channel) (COM12) ClassGuid : {4d36e978-e325-11ce-bfc1-08002be10318} CompatibleID : {USB\Class_02&SubClass_02&Prot_01, USB\Class_02&SubClass_02, USB\Class_02} ConfigManagerErrorCode : 0 ConfigManagerUserConfig : False CreationClassName : Win32_PnPEntity Description : TinyG v2 (Data Channel) DeviceID : USB\VID_1D50&PID_606D&MI_02\6&2F09EA14&0&0002 ErrorCleared : ErrorDescription : HardwareID : {USB\VID_1D50&PID_606D&REV_0097&MI_02, USB\VID_1D50&PID_606D&MI_02} InstallDate : LastErrorCode : Manufacturer : Synthetos (www.synthetos.com) Name : TinyG v2 (Data Channel) (COM12) PNPDeviceID : USB\VID_1D50&PID_606D&MI_02\6&2F09EA14&0&0002 PowerManagementCapabilities : PowerManagementSupported : Service : usbser Status : OK StatusInfo : SystemCreationClassName : Win32_ComputerSystem SystemName : JOHN-ATIV PSComputerName : JOHN-ATIV */ // item is a SWbemObject, but really a Win32_Process itemRaw, _ := oleutil.CallMethod(result, "ItemIndex", i) item := itemRaw.ToIDispatch() defer item.Release() asString, _ := oleutil.GetProperty(item, "Name") //log.Println(asString.ToString()) // get the com port //if false { s := strings.Split(asString.ToString(), "(COM")[1] s = "COM" + s s = strings.Split(s, ")")[0] list[i].Name = s list[i].FriendlyName = asString.ToString() //} // get the deviceid so we can figure out related ports // it will look similar to // USB\VID_1D50&PID_606D&MI_00\6&2F09EA14&0&0000 deviceIdStr, _ := oleutil.GetProperty(item, "DeviceID") devIdItems := strings.Split(deviceIdStr.ToString(), "&") log.Printf("DeviceId elements:%v", devIdItems) if len(devIdItems) > 3 { list[i].SerialNumber = devIdItems[3] //list[i].IdProduct = strings.Replace(devIdItems[1], "PID_", "", 1) //list[i].IdVendor = strings.Replace(devIdItems[0], "USB\\VID_", "", 1) } else { list[i].SerialNumber = deviceIdStr.ToString() } pidMatch := regexp.MustCompile("PID_(....)").FindAllStringSubmatch(deviceIdStr.ToString(), -1) if len(pidMatch) > 0 { if len(pidMatch[0]) > 1 { list[i].IdProduct = pidMatch[0][1] } } vidMatch := regexp.MustCompile("VID_(....)").FindAllStringSubmatch(deviceIdStr.ToString(), -1) if len(vidMatch) > 0 { if len(vidMatch[0]) > 1 { list[i].IdVendor = vidMatch[0][1] } } manufStr, _ := oleutil.GetProperty(item, "Manufacturer") list[i].Manufacturer = manufStr.ToString() descStr, _ := oleutil.GetProperty(item, "Description") list[i].Product = descStr.ToString() //classStr, _ := oleutil.GetProperty(item, "CreationClassName") //list[i].DeviceClass = classStr.ToString() } for index, element := range list { log.Printf("index:%v, name:%v, friendly:%v ", index, element.Name, element.FriendlyName) log.Printf("pid:%v, vid:%v", element.IdProduct, element.IdVendor) for index2, element2 := range list { if index == index2 { continue } if element.SerialNumber == element2.SerialNumber { log.Printf("Found related element1:%v, element2:%v", element, element2) list[index].RelatedNames = append(list[index].RelatedNames, element2.Name) } } } return list, err }
func (sheet Sheet) Select() (err error) { defer Except("Sheet.Select", &err) _, err = oleutil.CallMethod(sheet.Idisp, "Select") return }
func (sheet Sheet) Delete() (err error) { defer Except("Sheet.Delete", &err) _, err = oleutil.CallMethod(sheet.Idisp, "Delete") return }
// Query runs the WQL query and appends the values to dst. // // dst must have type *[]S or *[]*S, for some struct type S. Fields selected in // the query must have the same name in dst. Supported types are all signed and // unsigned integers, time.Time, string, bool, or a pointer to one of those. // Array types are not supported. // // By default, the local machine and default namespace are used. These can be // changed using connectServerArgs. See // http://msdn.microsoft.com/en-us/library/aa393720.aspx for details. func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error { dv := reflect.ValueOf(dst) if dv.Kind() != reflect.Ptr || dv.IsNil() { return ErrInvalidEntityType } dv = dv.Elem() mat, elemType := checkMultiArg(dv) if mat == multiArgTypeInvalid { return ErrInvalidEntityType } lock.Lock() defer lock.Unlock() runtime.LockOSThread() defer runtime.UnlockOSThread() err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED) if err != nil { oleerr := err.(*ole.OleError) // S_FALSE = 0x00000001 // CoInitializeEx was already called on this thread if oleerr.Code() != ole.S_OK && oleerr.Code() != 0x00000001 { return err } } else { // Only invoke CoUninitialize if the thread was not initizlied before. // This will allow other go packages based on go-ole play along // with this library. defer ole.CoUninitialize() } unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator") if err != nil { return err } defer unknown.Release() wmi, err := unknown.QueryInterface(ole.IID_IDispatch) if err != nil { return err } defer wmi.Release() // service is a SWbemServices serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...) if err != nil { return err } service := serviceRaw.ToIDispatch() defer serviceRaw.Clear() // result is a SWBemObjectSet resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query) if err != nil { return err } result := resultRaw.ToIDispatch() defer resultRaw.Clear() count, err := oleInt64(result, "Count") if err != nil { return err } // Initialize a slice with Count capacity dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count))) var errFieldMismatch error for i := int64(0); i < count; i++ { err := func() error { // item is a SWbemObject, but really a Win32_Process itemRaw, err := oleutil.CallMethod(result, "ItemIndex", i) if err != nil { return err } item := itemRaw.ToIDispatch() defer itemRaw.Clear() ev := reflect.New(elemType) if err = c.loadEntity(ev.Interface(), item); err != nil { if _, ok := err.(*ErrFieldMismatch); ok { // We continue loading entities even in the face of field mismatch errors. // If we encounter any other error, that other error is returned. Otherwise, // an ErrFieldMismatch is returned. errFieldMismatch = err } else { return err } } if mat != multiArgTypeStructPtr { ev = ev.Elem() } dv.Set(reflect.Append(dv, ev)) return nil }() if err != nil { return err } } return errFieldMismatch }