Exemple #1
0
    def __init__(self, dest_widget, src_hdl=0x00010010):
        """Crée un stream."""
        if sys.platform == 'win32':
            self._destWidget = dest_widget
            self._src_hdl = src_hdl

            self.src_window_dc = win32gui.GetDC(self._src_hdl)

            # Récupère l'handle et le DC du dest_widget
            self._dest_hdl = dest_widget.winfo_id()
            self.dest_window_dc = win32gui.GetDC(self._dest_hdl)

            # Crée un DC compatible pour la sauvegarde
            self.mem_dc = win32gui.CreateCompatibleDC(self.dest_window_dc)
            if self.mem_dc is None:
                log.add("Échec de la création du compatibleDC.")
                return

            self.dest_rect_dc = win32gui.GetClientRect(self._dest_hdl)
            self.src_rect_dc = win32gui.GetClientRect(self._src_hdl)

            win32gui.SetStretchBltMode(self.dest_window_dc, win.HALFTONE)
            self._hasToRun = False

            self.timer = InfiniteTimer(1 / 24, self.run)
        elif sys.platform == 'linux':
            """TODO : Lalie ?"""
            pass
Exemple #2
0
def xiazhu(s, hwnd):
    time.sleep(0.5)
    ##win32gui.SetForegroundWindow(hwnd)
    windll.user32.SetCursorPos(673, 350)
    hdc = win32gui.GetDC(hwnd)
    color1 = color2 = win32gui.GetPixel(hdc, 673, 350)
    win32gui.ReleaseDC(hwnd, hdc)
    while color1 == color2 and color1 == 2787168:
        time.sleep(1)
        hdc = win32gui.GetDC(hwnd)
        color2 = win32gui.GetPixel(hdc, 673, 350)
        win32gui.ReleaseDC(hwnd, hdc)
Exemple #3
0
def get_realtime_pixel():  # 실시간으로 마우스 위치의 픽셀을 출력하는 함수
    prev = win32api.GetCursorPos()
    while True:
        mouse_p = win32api.GetCursorPos()
        if prev != mouse_p:
            print('Hex : ' + str(
                hex(
                    win32gui.GetPixel(
                        win32gui.GetDC(win32gui.GetDesktopWindow()),
                        mouse_p[0], mouse_p[1]))) + ' Int : ' + str(
                            win32gui.GetPixel(
                                win32gui.GetDC(win32gui.GetDesktopWindow()),
                                mouse_p[0], mouse_p[1])))
        prev = mouse_p
Exemple #4
0
 def brain_eval(x, y):
     wnd = win32gui.GetForegroundWindow()
     dc = win32gui.GetDC(wnd)
     rc = win32gui.GetClientRect(wnd)
     c = str(board[x][y])
     win32gui.ExtTextOut(dc, rc[2] - 15, 3, 0, None, c, ())
     win32gui.ReleaseDC(wnd, dc)
def grab_im():
    while True:
        cursor_current_x, cursor_current_y = 0, 0
        crop_im = False
        win_DC = win32gui.GetDC(0)
        cursor_origin_x, cursor_origin_y = win32gui.GetCursorPos()
        full_image = ImageGrab.grab(bbox=(0, 0, win32api.GetSystemMetrics(0),
                                          win32api.GetSystemMetrics(1)))

        while win32api.GetAsyncKeyState(win32con.VK_CONTROL) < 0:
            if not crop_im:
                crop_im = True
            cursor_current_x, cursor_current_y = win32gui.GetCursorPos()
            win32gui.MoveToEx(win_DC, cursor_origin_x, cursor_origin_y)
            win32gui.LineTo(win_DC, cursor_origin_x, cursor_current_y)
            win32gui.MoveToEx(win_DC, cursor_origin_x, cursor_current_y)
            win32gui.LineTo(win_DC, cursor_current_x, cursor_current_y)
            win32gui.MoveToEx(win_DC, cursor_current_x, cursor_current_y)
            win32gui.LineTo(win_DC, cursor_current_x, cursor_origin_y)
            win32gui.MoveToEx(win_DC, cursor_current_x, cursor_origin_y)
            win32gui.LineTo(win_DC, cursor_origin_x, cursor_origin_y)

        if crop_im:
            cropped_image = full_image.crop(
                (min(cursor_current_x,
                     cursor_origin_x), min(cursor_current_y, cursor_origin_y),
                 max(cursor_current_x,
                     cursor_origin_x), max(cursor_current_y, cursor_origin_y)))
            return cropped_image
        sleep(.01)
Exemple #6
0
    def prep_menu_icon(self,
                       icon):  #Couldn't get this to work with pngs, only ico
        # First load the icon.
        ico_x = win32api.GetSystemMetrics(win32con.SM_CXSMICON)
        ico_y = win32api.GetSystemMetrics(win32con.SM_CYSMICON)
        hicon = win32gui.LoadImage(0, icon, win32con.IMAGE_ICON, ico_x, ico_y,
                                   win32con.LR_LOADFROMFILE)

        hdcBitmap = win32gui.CreateCompatibleDC(0)
        hdcScreen = win32gui.GetDC(0)
        hbm = win32gui.CreateCompatibleBitmap(hdcScreen, ico_x, ico_y)
        hbmOld = win32gui.SelectObject(hdcBitmap, hbm)
        # Fill the background.
        brush = win32gui.GetSysColorBrush(win32con.COLOR_MENU)
        win32gui.FillRect(hdcBitmap, (0, 0, 16, 16), brush)
        # unclear if brush needs to be feed.  Best clue I can find is:
        # "GetSysColorBrush returns a cached brush instead of allocating a new
        # one." - implies no DeleteObject
        # draw the icon
        win32gui.DrawIconEx(hdcBitmap, 0, 0, hicon, ico_x, ico_y, 0, 0,
                            win32con.DI_NORMAL)
        win32gui.SelectObject(hdcBitmap, hbmOld)
        win32gui.DeleteDC(hdcBitmap)

        return hbm
Exemple #7
0
def ScreenShot(dpath): 
    hwndDC = win32gui.GetDC(hwnd)
    memDc = win32gui.CreateCompatibleDC(hwndDC)
    hBmp   = win32gui.CreateCompatibleBitmap(hwndDC, 800, 600)
    oldBmp = win32gui.SelectObject(memDc, hBmp)

    #win32gui.BitBlt(memDc,0,0,800,600,hwndDC,0,0,win32con.SRCCOPY);
    ctypes.windll.user32.PrintWindow(hwnd, memDc, 1)
    
    filename = TimeStamp()
    bmpname = dpath + filename + '.bmp'

    saveBitMap = win32ui.CreateBitmapFromHandle(hBmp)
    saveDC = win32ui.CreateDCFromHandle(memDc)
    saveBitMap.SaveBitmapFile(saveDC, bmpname)

    win32gui.SelectObject(memDc, oldBmp)
    win32gui.DeleteObject(memDc)
    win32gui.DeleteObject(hBmp)
    win32gui.ReleaseDC(hwnd, hwndDC)
    
    jpgname = bmpname[:-4]+".jpg"
    Image.open(bmpname).save(jpgname)
    SafeDelete(bmpname)
    
    screenList.append(jpgname)
    if len(screenList) > 300:
        SafeDelete(screenList[0])
        del(screenList[0])
Exemple #8
0
def test(exePath):
    import win32ui
    import win32gui
    import win32con
    import win32api

    # ico_x = win32api.GetSystemMetrics(win32con.SM_CXICON)
    # ico_y = win32api.GetSystemMetrics(win32con.SM_CYICON)
    ico_x = 32
    ico_y = 32

    # exePath = "c:/windows/system32/shell32.dll"
    large, small = win32gui.ExtractIconEx(exePath, 0)
    useIcon = large[0]
    destroyIcon = small[0]
    win32gui.DestroyIcon(destroyIcon)
    print('dd', (useIcon))

    hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
    hbmp = win32ui.CreateBitmap()
    hbmp.CreateCompatibleBitmap(hdc, ico_x, ico_x)
    hdc = hdc.CreateCompatibleDC()

    hdc.SelectObject(hbmp)
    hdc.DrawIcon((0, 0), useIcon)
    savePath = "d:/test.bmp"
    hbmp.SaveBitmapFile(hdc, savePath)
Exemple #9
0
def window_capture(hwnd):
    try:
        #f = ctypes.windll.dwmapi.DwmGetWindowAttribute
        f = ctypes.windll.shcore.SetProcessDpiAwareness
    except WindowsError:
        f = None

    if not f:
        exit(0)
    else:
        PROCESS_SYSTEM_DPI_AWARE = 1
        f(PROCESS_SYSTEM_DPI_AWARE)

    l, t, r, b = win32gui.GetClientRect(hwnd)
    w = r - l
    h = b - t

    hwnd_client_dc = win32gui.GetDC(hwnd)
    img_dc = win32ui.CreateDCFromHandle(hwnd_client_dc)
    mem_dc = img_dc.CreateCompatibleDC()

    screenshot = win32ui.CreateBitmap()
    screenshot.CreateCompatibleBitmap(img_dc, w, h)
    mem_dc.SelectObject(screenshot)

    mem_dc.BitBlt((0, 0), (w, h), img_dc, (l, t), win32con.SRCCOPY)

    screenshot.SaveBitmapFile(mem_dc, 'screenshot.bmp')
    mem_dc.DeleteDC()
    win32gui.DeleteObject(screenshot.GetHandle())
Exemple #10
0
def do_test():
    if not set_dpi_aware():
        return

    hwnd = find_mine()
    l, t, w, h = get_client_rect(hwnd)

    handle_client_dc = win32gui.GetDC(hwnd)
    client_dc = win32ui.CreateDCFromHandle(handle_client_dc)
    mem_dc = client_dc.CreateCompatibleDC()

    bmp = win32ui.CreateBitmap()
    bmp.CreateCompatibleBitmap(client_dc, w, h)
    mem_dc.SelectObject(bmp)

    mine_area = get_mine_area(get_shot(bmp, mem_dc, client_dc, l, t, w, h))

    while True:
        # get window shot
        img_shot = get_shot(bmp, mem_dc, client_dc, l, t, w, h)
        
        # process
        digits = process_mine_img(img_shot, mine_area)
        print digits
        break


    mem_dc.DeleteDC()
    client_dc.DeleteDC()
    win32gui.ReleaseDC(hwnd, handle_client_dc)
Exemple #11
0
def extract_icon(exefilename):
    """Get the first resource icon from win32 exefilename and returns it a s PNG bytes array"""
    ico_x = win32api.GetSystemMetrics(win32con.SM_CXICON)
    ico_y = win32api.GetSystemMetrics(win32con.SM_CYICON)

    large, small = win32gui.ExtractIconEx(exefilename,0)
    temp_dir = tempfile.mkdtemp()
    try:
        hdc = win32ui.CreateDCFromHandle( win32gui.GetDC(0) )
        hbmp = win32ui.CreateBitmap()
        hbmp.CreateCompatibleBitmap( hdc, ico_x, ico_x )
        hdc = hdc.CreateCompatibleDC()

        hdc.SelectObject( hbmp )
        hdc.DrawIcon( (0,0), large[0] )

        bmp_temp = os.path.join(temp_dir,"icon.bmp")
        hbmp.SaveBitmapFile(hdc,bmp_temp)

        im = Image.open(bmp_temp)
        png_temp = os.path.join(temp_dir,"icon.png")
        with open(png_temp,'wb') as png:
            im.save(png, "PNG")
            result = open(png_temp,'rb').read()

        return result
    finally:
        win32gui.DestroyIcon(small[0])
        win32gui.DestroyIcon(large[0])
        if os.path.isdir(temp_dir):
            shutil.rmtree(temp_dir)
Exemple #12
0
def get_pixel_rgb(pos):
    hwnd = get_hos_handler()
    x, y = pos
    dc = win32gui.GetDC(hwnd)
    rgbint = win32gui.GetPixel(dc, x, y)
    win32gui.ReleaseDC(hwnd, dc)
    return rgbint2rgbtuple(rgbint)
Exemple #13
0
def is_empty_pixel(offset_ratio_x, offset_ratio_y):
    rect = win32gui.GetClientRect(rotmg_hwnd)
    hdc = win32gui.GetDC(rotmg_hwnd)
    r, g, b = get_pixel_rgb(hdc, int(rect[2] * offset_ratio_x),
                            int(rect[3] * offset_ratio_y))
    return abs(r - EMPTY_R) < EPSILON and abs(g - EMPTY_G) < EPSILON and abs(
        b - EMPTY_B) < EPSILON
Exemple #14
0
def getPixel(x, y):
    hwnd = win32gui.WindowFromPoint((x, y))
    hdc = win32gui.GetDC(hwnd)
    x1, y1 = win32gui.ScreenToClient(hwnd, (x, y))
    color = win32gui.GetPixel(hdc, x1, y1)
    win32gui.ReleaseDC(hwnd, hdc)
    return color % 256, color / 256 % 256, color / 256 / 256
def get_icon(PATH, size):
    SHGFI_ICON = 0x000000100
    SHGFI_ICONLOCATION = 0x000001000
    if size == "small":
        SHIL_SIZE = 0x00001
    elif size == "large":
        SHIL_SIZE = 0x00002
    else:
        raise TypeError(
            "Invalid argument for 'size'. Must be equal to 'small' or 'large'")

    ret, info = shell.SHGetFileInfo(
        PATH, 0, SHGFI_ICONLOCATION | SHGFI_ICON | SHIL_SIZE)
    hIcon, iIcon, dwAttr, name, typeName = info
    ico_x = win32api.GetSystemMetrics(win32con.SM_CXICON)
    hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
    hbmp = win32ui.CreateBitmap()
    hbmp.CreateCompatibleBitmap(hdc, ico_x, ico_x)
    hdc = hdc.CreateCompatibleDC()
    hdc.SelectObject(hbmp)
    hdc.DrawIcon((0, 0), hIcon)
    win32gui.DestroyIcon(hIcon)

    bmpinfo = hbmp.GetInfo()
    bmpstr = hbmp.GetBitmapBits(True)
    img = Image.frombuffer("RGBA", (bmpinfo["bmWidth"], bmpinfo["bmHeight"]),
                           bmpstr, "raw", "BGRA", 0, 1)

    if size == "small":
        img = img.resize((16, 16), Image.ANTIALIAS)
    return img
Exemple #16
0
def get_real_size():
    hDC = win32gui.GetDC(0)
    # 横向分辨率
    w = win32print.GetDeviceCaps(hDC, win32con.DESKTOPHORZRES)
    # 纵向分辨率
    h = win32print.GetDeviceCaps(hDC, win32con.DESKTOPVERTRES)
    return w, h
Exemple #17
0
    def get_icon(filepath: Optional[str],
                 icon_save_directory: Optional[str] = None) -> Optional[str]:
        if not filepath:
            return None  # no file path to save the icon from

        # TODO: Get icons of different sizes.
        small, large = win32gui.ExtractIconEx(filepath, 0, 10)
        if len(large) <= 0:
            return None  # no icon to extract

        if len(small) > 0:
            win32gui.DestroyIcon(small[0])  # get rid of the small one

        hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
        ico_x = win32api.GetSystemMetrics(win32con.SM_CXICON)
        ico_y = win32api.GetSystemMetrics(win32con.SM_CYICON)
        hbmp = win32ui.CreateBitmap()
        hbmp.CreateCompatibleBitmap(hdc, ico_x, ico_y)
        hdc = hdc.CreateCompatibleDC()
        hdc.SelectObject(hbmp)
        hdc.DrawIcon((0, 0), large[0])

        executable_path = Path(filepath)
        icon_path = icon_name = f"icon_{executable_path.name}.bmp"
        if icon_save_directory:
            icon_path = str((Path(icon_save_directory) / icon_name).resolve())
        hbmp.SaveBitmapFile(hdc, icon_path)
        with Image.open(icon_path) as img:
            buffered = BytesIO()
            img.save(buffered, format="PNG")
            image_string = base64.b64encode(buffered.getvalue()).decode()
        if not icon_save_directory:
            Path(icon_path).unlink()
        return image_string
Exemple #18
0
def checkHealth(keyCode):
    x, y = calculateHPxy(80)
    color = win32gui.GetPixel(win32gui.GetDC(win32gui.GetActiveWindow()), x, y)
    r, g, b = rgbint2rgbtuple(color)
    if r < 50:
        time.sleep(0.3)
        useSkill(keyCode)
Exemple #19
0
def save_icon(icon_path, save_path):
    if icon_path == "Error: No path found":
        return False

    icon_path = icon_path.replace("\\", "/")
    try:
        iconX = win32api.GetSystemMetrics(win32con.SM_CXICON)
        iconY = win32api.GetSystemMetrics(win32con.SM_CXICON)

        large, small = win32gui.ExtractIconEx(icon_path, 0)
        win32gui.DestroyIcon(small[0])

        hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
        hbmp = win32ui.CreateBitmap()
        hbmp.CreateCompatibleBitmap(hdc, iconX, iconX)
        hdc = hdc.CreateCompatibleDC()

        hdc.SelectObject(hbmp)
        hdc.DrawIcon((0, 0), large[0])

        bmpstr = hbmp.GetBitmapBits(True)
        from PIL import Image
        img = Image.frombuffer('RGBA', (32, 32), bmpstr, 'raw', 'BGRA', 0, 1)
        extrema = img.convert("L").getextrema()
        if "Chrome" in icon_path:
            pass
            # print("TEST")
        if extrema[1] < 250:
            img.save(save_path)
        return True
    except Exception as e:
        # print("Error:")
        # print(e)
        return False
Exemple #20
0
 def get_resolution(self):
     hDC = win32gui.GetDC(0)
     self.resolution = win32print.GetDeviceCaps(
         hDC, win32con.DESKTOPHORZRES) / win32api.GetSystemMetrics(
             win32con.SM_CXSCREEN)
     self.logger.get_log().debug('屏幕分辨率为:' + str(self.resolution))
     return None
Exemple #21
0
def get_icon_from_window(hwnd):
    """Create an icon file in the temp directory for the window handle and return its path.

    Actually, it is not unclear how the Windows API works to retrieve the icon info and save it as icon...
    """
    hicon = win32api.SendMessage(hwnd, win32con.WM_GETICON, win32con.ICON_BIG)
    if hicon == 0:
        hicon = win32api.SendMessage(hwnd, win32con.WM_GETICON,
                                     win32con.ICON_SMALL)
    if hicon == 0:
        hicon = win32gui.GetClassLong(hwnd, win32con.GCL_HICON)
    if hicon == 0:
        hicon = win32gui.GetClassLong(hwnd, win32con.GCL_HICONSM)
    if hicon == 0:
        hicon = get_hicon_from_exe(hwnd)
    if hicon == 0:
        return None

    ico_x = win32api.GetSystemMetrics(win32con.SM_CXICON)
    # creating a destination memory DC
    hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
    hbmp = win32ui.CreateBitmap()
    hbmp.CreateCompatibleBitmap(hdc, ico_x, ico_x)
    hdc = hdc.CreateCompatibleDC()
    hdc.SelectObject(hbmp)
    hdc.DrawIcon((0, 0), hicon)
    # file_path = TEMP_DIR + "\Icontemp" + str(hwnd) + ".bmp"
    file_path = ICONFILE_TEMP_STR.format(str(hwnd))
    hbmp.SaveBitmapFile(hdc, file_path)

    return file_path
Exemple #22
0
 def getScale(self):
     hDC = win32gui.GetDC(0)
     widthOriginal = win32print.GetDeviceCaps(hDC, win32con.DESKTOPHORZRES)
     #heightOriginal	= win32print.GetDeviceCaps(hDC, win32con.DESKTOPVERTRES)
     #dpiOriginal	= win32print.GetDeviceCaps(hDC, win32con.LOGPIXELSX)
     widthReal = GetSystemMetrics(0)
     #heightReal		= GetSystemMetrics(1)
     return widthOriginal / widthReal
Exemple #23
0
 def brain_eval(x, y):
     # TODO check if it works as expected
     wnd = win32gui.GetForegroundWindow()
     dc = win32gui.GetDC(wnd)
     rc = win32gui.GetClientRect(wnd)
     c = str(agent.board[x, y])
     win32gui.ExtTextOut(dc, rc[2] - 15, 3, 0, None, c, ())
     win32gui.ReleaseDC(wnd, dc)
Exemple #24
0
 def getWH(self):
     """获取真实的分辨率"""
     hDC = win32gui.GetDC(0)
     # 横向分辨率
     w = win32print.GetDeviceCaps(hDC, win32con.DESKTOPHORZRES)
     # 纵向分辨率
     h = win32print.GetDeviceCaps(hDC, win32con.DESKTOPVERTRES)
     return w,h
Exemple #25
0
def readPixel(x, y):
    if x >= 1920:
        x = 1919
    if y >= 1080:
        y = 1079
    color = win32gui.GetPixel(win32gui.GetDC(win32gui.GetActiveWindow()), x, y)
    r, g, b = rgbint2rgbtuple(color)
    return r, g, b
def get_hdc():
    hwnd = win32gui.FindWindow(None, "Kokoro@kokoro")
    if not hwnd:
        print('Window not found')
        exit(1)
    hdc = win32gui.GetDC(hwnd)
    assert hdc
    return hwnd, hdc
 def drawtext(self, text):
     '''
     在鼠标所在为止写入一个字符串
     '''
     t = win32gui.GetDC(win32gui.GetDesktopWindow())
     w,h = win32api.GetSystemMetrics(0),win32api.GetSystemMetrics(1)
     x,y = win32api.GetCursorPos()
     win32gui.DrawText(t,text,-1,(x,y,w,h),8)
Exemple #28
0
def IconToFile(hlib, tmpDirName, group_name):
    libc = ctypes.CDLL(ctypes.util.find_library('c'))
    libc.memcpy.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    libc.memcpy.restype = ctypes.c_char_p

    # patch FindResourceW, ctypes.windll.kernel32.SizeofResource
    FindResourceW = ctypes.windll.kernel32.FindResourceW
    FindResourceW.argtypes = [
        ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p
    ]
    FindResourceW.restype = ctypes.c_void_p
    SizeofResource = ctypes.windll.kernel32.SizeofResource
    SizeofResource.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
    SizeofResource.restype = ctypes.c_size_t

    hRes = win32api.LoadResource(hlib, win32con.RT_GROUP_ICON, group_name)
    mem_icon_dir = ctypes.windll.kernel32.LockResource(hRes)

    # 32 bits color; 16 and 256 colors are too old

    icon_size = 256
    icon_name = ctypes.windll.user32.LookupIconIdFromDirectoryEx(
        mem_icon_dir, True, icon_size, icon_size, 0x00000000)
    sys.stderr.write("icon_name=%s\n" % str(icon_name))
    hResInfo = FindResourceW(hlib, icon_name, win32con.RT_ICON)
    size = ctypes.windll.kernel32.SizeofResource(hlib, hResInfo)
    rec = win32api.LoadResource(hlib, win32con.RT_ICON, icon_name)
    mem_icon = ctypes.windll.kernel32.LockResource(rec)

    # And this is some differ (copy data to Python buffer)
    binary_data = (ctypes.c_ubyte * size)()
    libc.memcpy(binary_data, mem_icon, size)
    hIconRet = ctypes.windll.user32.CreateIconFromResourceEx(
        binary_data, size, True, 0x00030000, 0, 0, 0x00000000)
    info = win32gui.GetIconInfo(hIconRet)
    bminfo = win32gui.GetObject(info[4])

    # generate bitmap by drawing the icon
    hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
    hbmp = win32ui.CreateBitmap()
    hbmp.CreateCompatibleBitmap(hdc, bminfo.bmWidth, bminfo.bmHeight)
    hcdc = hdc.CreateCompatibleDC()
    hcdc.SelectObject(hbmp)
    win32gui.DrawIconEx(hcdc.GetHandleOutput(), 0, 0, hIconRet, bminfo.bmWidth,
                        bminfo.bmHeight, 0, 0, 0x0003)

    # Need temp directory or generate image on the fly, for inclusion into an HTML page.
    # Temp file visible from HTTP server.
    # An alternative is to send the file content to a socket stream.
    # MIME type is "image/bmp"
    imgFilNam = "icon-%03dx%03d-%05d-%03d.bmp" % (
        bminfo.bmWidth, bminfo.bmHeight, group_name, icon_name)
    if tmpDirName:
        imgFilNam = tmpDirName + imgFilNam
    sys.stderr.write("Generating %s\n" % imgFilNam)
    hbmp.SaveBitmapFile(hcdc, imgFilNam)
    win32gui.DestroyIcon(hIconRet)
    return imgFilNam
Exemple #29
0
def bitmapFromHIcon(hIcon):
    hdc = win32ui.CreateDCFromHandle(win32gui.GetDC(0))
    hbmp = win32ui.CreateBitmap()
    hbmp.CreateCompatibleBitmap(hdc, 40, 40)
    hdc = hdc.CreateCompatibleDC()
    hdc.SelectObject(hbmp)
    hdc.DrawIcon((0, 0), hIcon)
    hdc.DeleteDC()
    return hbmp.GetHandle()
Exemple #30
0
def _get_device_caps(constant):
    dc = None
    try:
        gdi32 = ctypes.windll.gdi32
        dc = win32gui.GetDC(None)
        return gdi32.GetDeviceCaps(dc, constant)
    finally:
        if dc:
            win32gui.ReleaseDC(None, dc)