Windows ile çalışmak için API işlevlerini kazanın. Windows API'ye Giriş Windows API nedir?

Nihayet! Nihayet! Bugün tam teşekküllü bir Windows penceresi oluşturmaya başlayacağız. Elveda sefil konsol!!!

Bu noktada, zaten iyi bir C++ sözdizimi bilgisine sahip olmanız, dallar ve döngülerle çalışabilmeniz ve fonksiyonların nasıl çalıştığını iyi anlamış olmanız gerekir. Bir deniz savaşında ustalaştıysanız, tüm bunları öğrendiğinizi düşünebilirsiniz.

Macar gösterimi

WinAPI'de karşılaşacağımız tüm kodlar Macarca formda yazılmıştır. Bu böyle bir kodlama kuralı.

Bu durumda, değişken adından önce türün ilk harfi gelir. Değişken ve fonksiyon adlarındaki tüm kelimeler büyük harfle başlar.

İşte bazı önekler:

b - bool tipi değişken.
l, uzun tamsayı türünde bir değişkendir.
w - kelimeden (kelime) - 16 bit. İşaretsiz kısa türünde değişken.
dw - çift kelimeden (çift kelime) - 32 bit. Değişken türü işaretsiz uzun.
sz - dize sıfırla sonlandırıldı. Her zaman kullandığımız normal bir dize.
p veya lp - işaretçi (işaretçiden). lp (uzun işaretçiden) - bu işaretçiler geçmişten geçti. Şimdi lp ve p aynı anlama geliyor.
h - tanımlayıcı (tanımlayıcıdan).

Örneğin, işaretçi şu şekilde çağrılır:

geçersiz*pData;

Bu gösterim Microsoft tarafından kullanılır. Birçoğu, değişkenleri bu şekilde adlandırmayı eleştiriyor. Ancak bunun gibi şeyler (kodlama kuralları) büyük şirketlerde hayati önem taşır.

Sabit tanımlayıcıların genellikle yalnızca büyük harflerden oluştuğunu hatırlatmama izin verin: WM_DESTRY. WM_DESTOY 2'dir, sabit define ile tanımlanır.

Ek olarak, winAPI birçok geçersiz kılınan tür kullanır. Bu sayfada - http://msdn.Microsoft.com/en-us/library/aa383751(VS.85).aspx , tüm Windows türlerinin açıklamalarını bulabilirsiniz (İngilizce).

Ve anlamadığımız bir şey daha. İşaretçilere genellikle NULL değeri atanır. Bunu yalnızca 0 olarak düşünün ve NULL (sıfır) olarak ayarlanan işaretçiler herhangi bir bellek konumuna işaret etmez.

Windows API'si (WinAPI)

Tüm Windows programları özel bir WinAPI programlama arabirimi kullanır. Programınızı Windows ile uyumlu hale getiren bir dizi C işlevi ve yapısıdır.

Windows API, işletim sistemiyle çalışmak için muazzam yeteneklere sahiptir. Hatta sınırsız denilebilir.

Tüm WinAPI özelliklerinin yüzde birini bile kapsamayacağız. Başlangıçta daha fazla malzeme almak istedim ama çok zaman alacaktı ve WinAPI bataklığında takılıp kaldık, birkaç yıl içinde DirectX'e ulaşacaktık WinAPI'nin açıklaması iki ders alacak (bu ders dahil) .Onlarda sadece Windows altındaki uygulama çerçevesini ele alacağız.

Tıpkı bir DOS programı gibi bir Windows programının da bir ana işlevi vardır. İşte bu işlev WinMain olarak adlandırılır.

WinAna İşlev

Windows programı aşağıdaki bölümlerden oluşur (tüm bunlar WinMain içinde olur):

Bir pencere sınıfı oluşturun ve kaydedin. C++ sınıfları ile karıştırmayın. WinAPI C ile yazılmıştır, bizim için kelimenin olağan anlamında sınıflar yoktur.
Bir program penceresi oluşturma.
İletilerin işlendiği ana döngü.
Program mesajlarını bir pencere prosedüründe işleme. Bir pencere yordamı normal bir işlevdir.
Bu dört nokta, Windows programının temelidir. Bu ve bir sonraki derste, tüm bunları ayrıntılı olarak analiz edeceğiz. Programın açıklamasında kafanız karışırsa, bu noktalara geri dönün.

Şimdi tüm bunlara ayrıntılı olarak bakalım:

WinAPI: WNDCLASS Yapısı

Her şeyden önce, WNDCLASS yapısal değişkenini oluşturup doldurmanız ve ardından buna göre pencere sınıfını kaydetmeniz gerekir.

İşte bu yapının neye benzediği:

c++ kodu typedef struct ( UINT stili; // pencere stili WNDPROC lpfnWndProc; // pencere yordamına işaretçi int cbClsExtra; // sınıftan sonra fazladan bayt. Her zaman 0'a ayarla int cbWndExtra; // pencere örneğinden sonra fazladan bayt. Her zaman 0'a ayarla HINSTANCE hInstance ; / / uygulama örneği WinMain HICON hIcon'a parametre olarak geçirilir; // uygulama simgesi HCURSOR hCursor; // uygulama imleci HBRUSH hbrBackground; // arka plan rengi LPCTSTR lpszMenuName; // menü adı LPCTSTR lpszClassName; // sınıf adı ) WNDCLASS, * PWNDCLASS ;

WinAPI'deki WNDCLASS yapısı, oluşturulan pencerenin temel özelliklerini tanımlar: simgeler, fare imlecinin türü, pencerenin bir menüsü olup olmadığı, pencerenin hangi uygulamaya ait olacağı...

Bu yapıyı doldurduktan sonra, ona göre bir pencere sınıfı kaydedebilirsiniz. Bu, C++'daki gibi sınıflarla ilgili değil. Bunun yerine, pencere sınıfının böyle bir şablon olduğunu düşünebiliriz, onu sisteme kaydettiniz ve şimdi bu şablona göre birkaç pencere oluşturulabilir. Ve tüm bu pencereler, WNDCLASS yapı değişkeninde tanımladığınız özelliklere sahip olacaktır.

WinAPI: CreateWindow İşlevi

Pencere sınıfını kaydettikten sonra, uygulamanın ana penceresi onun temelinde oluşturulur (şimdi ikinci noktaya geçtik). Bu, CreateWindow işlevi kullanılarak yapılır. Aşağıdaki prototipe sahiptir:

c++ kodu HWND CreateWindow(LPCTSTR lpClassName, // sınıf adı LPCTSTR lpWindowName, // pencere adı (başlık çubuğunda görüntülenir) DWORD dwStyle, // pencere stili int x, // ekranın sol kenarından yatay koordinat int y, // int nWidth, // pencere genişliği int nHeight, // pencere yüksekliği HWND hWndParent, // üst pencere HMENU hMenu, // menü tanıtıcısı HINSTANCE hInstance, // uygulama örneği LPVOID lpParam // parametre; her zaman NULL olarak ayarlanır);

Pencere sınıfında (WNDCLASS yapısı) pencerenin temel özellikleri ayarlanmışsa, o zaman burada - her pencere için daha spesifik: pencere boyutu, koordinatlar ...

Bu işlev bir pencere tanıtıcısı döndürür. Tanımlayıcının yardımıyla pencereye başvurabilirsiniz, bu bir tanımlayıcı gibidir.

Burada birçok yeni tür olduğunu unutmayın. Aslında hepsi eski, daha yeni tanımlandı. Örneğin: HWND, HANDLE tipinin geçersiz kılınmasıdır, bu da PVOID'in geçersiz kılınmasıdır ve bu da, boşluk* öğesinin geçersiz kılınmasıdır. Gerçek ne kadar derin! Ancak yine de HWND tipi geçersiz kılmak için bir işaretçidir.

Pencere birkaç bölümden oluşur. Hemen hemen her programda şunları göreceksiniz: pencerenin başlığı, sistem menüsü (pencerenin sol üst kısmındaki uygulama simgesine tıklarsanız), pencereyle çalışmak için üç sistem düğmesi: küçült, büyüt ve kapat. Ayrıca, uygulamada hemen hemen her zaman bir menü bulunur. Bu kesinlikle yapmayacağımız son şey. Ve elbette, pencerenin çoğu sözde tarafından işgal edilmiştir. kullanıcının genellikle çalıştığı müşteri alanı.

Pencere modu ile ilgili. DiectX ile uzun süre bir pencerede pratik yapacağız - tam ekran modunu kullanmayacağız.

Mesaj işleme

Önceki tüm programlarımızın Windows altındaki programlardan temel farkı mesaj işlemedir.

Örneğin, kullanıcı klavyede bir tuşa bastığında, bir tuşa basıldığına dair bir mesaj üretilir. Bu mesaj daha sonra kullanıcı tuşa bastığında aktif olan uygulamaya gönderilir.

Burada bir olay (olay) var - bir tuşa basıldı.

Bir olay şunlar olabilir: fare imlecini hareket ettirmek, uygulamanın odağını değiştirmek, bir klavye tuşuna basmak, bir pencereyi kapatmak. Bir çok olay var. Çok! Saniyede işletim sisteminde onlarca olay gerçekleşebilir.

Böylece, bir olay meydana geldiğinde, işletim sistemi bir mesaj oluşturur: falanca tuşa basıldı, fare imlecinin koordinatları değişti, yeni bir pencere açıldı.

Mesajlar hem işletim sistemi hem de çeşitli uygulamalar tarafından oluşturulabilir.

Mesaj bir yapıdır ve şöyle görünür:

c++ kodu typedef struct tagMSG ( HWND hwnd; // bu mesajı alacak pencere UINT mesajı; // mesaj kodu WPARAM wParam; // parametre LPARAM lParam; // parametre DWORD süresi; // mesajın oluştuğu zaman POINT pt; // fare koordinatları imleç) MSG;

Typedef'lerin yapıları nasıl yeniden tanımladığına dikkat edin.

Bu yapıyı oluşturmak için aşağıdaki kodu kullanabilirsiniz:

c++ kodu msg.messgae == 2; // msg.message == WM_DESTRY; // sabit WM_DESTRY ikiye eşittir

Burada mesaj kodunu içeren alan (mesaj adı sabit WM_DESTRY ile karşılaştırılır. WM - Windows Mesajından (Windows mesajı). WM_DESTROY - bu, pencere kapatıldığında (yok et - yok et) oluşturulan mesajdır.

Mesaj kodları sabitler kullanılarak tanımlanır ve WM_ ön ekine sahiptir: WM_CLOSE, WM_CREATE, vb.

MSG yapısı, Pencere Kolundan (pencere kolu veya pencere kolu) HWND tipini içerir. Bir pencereyi "tanımlayan" parçadır. Bu, tanımlayıcı (pencere adı) gibi bir şeydir.

Bu kelimeyi hatırla - tanıtıcı (tanımlayıcı, tanımlayıcı). Windows'ta bu kavram çok sık kullanılır. H ile başlayan hemen hemen tüm Windows türleri tanımlayıcıdır: simge tanımlayıcı, yazı tipi tanımlayıcı, uygulama örneği tanımlayıcı. Hatırladığım kadarıyla otuz tane var.

Windows'taki uygulamalar arasındaki tüm etkileşimler, aynı pencere tanımlayıcıları (HWND) kullanılarak gerçekleştirilir.

Başka bir önemli tanımlayıcı daha vardır - uygulama tanımlayıcısı (HINSTANCE - WinMain'in ilk parametresi) - bu, işletim sisteminin iki farklı programı karıştıramayacağı benzersiz bir uygulama tanımlayıcısıdır. Bir nevi barkod gibi. Daha sonra gözden geçireceğiz.

Kullanıcı her eylem gerçekleştirdiğinde, bir mesaj oluşturulur ve doldurulur: bu mesajı alması gereken pencerenin tanıtıcısı ayarlanır, mesaj tanımlayıcı ayarlanır, parametreler doldurulur, zaman (geçerli) doldurulur ve fare imlecinin koordinatları belirtilir (yapıya bakın).

Mesaj daha sonra işletim sisteminin mesaj kuyruğuna yerleştirilir. Sıra mesajımıza ulaştığında istenilen pencereye gönderilir (Windows tanımlayıcılar sayesinde her mesajın hangi pencereden gönderileceğini bilir). Bir uygulamaya bir mesaj geldiğinde, uygulamanın mesaj kuyruğuna yerleştirilir. Kuyruk ona ulaşır ulaşmaz işlenir.

Bakın, kullanıcının bir eylem gerçekleştirdiği an (bir olay meydana geldi ve bir mesaj oluşturuldu) ile programın bu eyleme tepki verdiği an (mesaj program tarafından işlendi) arasında birçok olay meydana geliyor. Sonuçta, hem Windows mesaj kuyruğunda hem de uygulama mesaj kuyruğunda birçok mesaj olabilir. İlk durumda yüzlerce, ikinci durumda en az birkaç tane konuşabiliriz.

Pencere prosedürü (Pencere prosedürü - WndProc)

Mesajın uygulamanın mesaj sırasına girdiği andan itibaren devam ediyoruz. Kuyruk ona ulaşır ulaşmaz işlenir. Her programdaki mesajları işlemek için özel bir işlev olmalıdır - bir pencere prosedürü. Genellikle WndProc (Pencere Prosedürü için) olarak adlandırılır. Pencere prosedür çağrısı, ana program döngüsünde bulunur ve döngünün her yinelemesinde yürütülür.

Mesajlar (yapısal MSG değişkenleri biçiminde) bu işleve parametreler biçiminde girer: bir pencere tanıtıcısı, bir mesaj tanımlayıcı ve iki parametre. Zaman ve nokta alanlarının pencere prosedürüne geçirilmediğine dikkat edin. Yani, mesaj zaten "ayrıştırılmıştır".

Pencere prosedürünün içinde, mesaj tanımlayıcısının kontrol edildiği bir anahtar dalı vardır. İşte basit bir pencere prosedürü örneği (tamamen işlevseldir):

c++ kodu// şimdilik HRESULT ve __stdcall'ı yok sayın. Bunlara daha sonra bakacağız HRESULT __stdcall WndProc(HWND hWnd, UINT mesajı, WPARAM wParam, LPARAM lParam) ( switch (mesaj) ( case WM_PAINT: // WM_PAINT mesaj işleme kodu dönüş 0; case WM_DESTROY: // WM_DESTROY mesaj işleme kodu return 0; ) // diğer tüm mesajlar için işleyici )

Ve sonuncusu ana döngüdür. O çok basit. Döngünün her yinelemesi, uygulamanın mesaj sırasını kontrol eder. Mesaj kuyruğunda bir mesaj varsa, sıradan çekilir. Ardından, döngü gövdesinde, kuyruktan alınan mesajı işlemek için bir pencere prosedürü çağrılır.

Genel olarak bugünlük bu kadar. WinAPI altındaki bir programın DOS altındaki bir programdan çok daha karmaşık olduğu zaten açıktır. Yukarıda yazdığım gibi bir sonraki derste çalışan bir programın kodunu inceleyeceğiz.

Alıştırma olarak yeni bir proje oluşturun. Yeni Proje penceresinde, şablonu (şablon) - Win32Project'i seçin (şimdiye kadar Win32 Konsol Uygulamasını seçtik). Aşağıdaki pencerelerden birinde, Boş Proje onay kutusunu (boş bir proje) işaretlemeyin, IDE boş bir program oluşturacaktır.

Project_name.cpp dosyasındaki koda yakından bakarsanız, tartıştığımız her şeyi bulacaksınız: MSG yapı değişkeni, WNDCLASS yapısının doldurulması, CreateWindow işleviyle pencerenin oluşturulması, ana program döngüsü. Ayrıca dosyada WndProc fonksiyonu tanımlanmıştır. Anahtar dallarındaki birkaç mesajı işler: WM_COMMAND, WM_PAINT, WM_DESTROY. Hepsini dosyada bulun.

Düşündüklerimize ek olarak, program birçok ek kod içerir. Bir sonraki sayıda, gereksiz her şeyin kesileceği programın koduna bakacağız. IDE'nin ürettiğinden çok daha basit ve net olacaktır.

Windows API (applicationprogramminginterface), Windows işletim sistemleri ailesi için bir kullanıcı modu sistem programlama arabirimidir. Windows'un 64 bit sürümlerinin piyasaya sürülmesinden önce, Windows işletim sistemlerinin 32 bit sürümleri için API, Windows API'nin orijinal 16 bit sürümünden (programlama arabirimi olarak hizmet veren) ayırt etmek için Win32 API olarak adlandırılıyordu. Windows'un ilk 16 bit sürümleri).

Windows API, aşağıdaki ana kategorilere ayrılan birkaç bin çağrılabilir işlevden oluşur:

• Temel Hizmetler.
• Bileşen Hizmetleri.
• Kullanıcı Arayüzü Hizmetleri.
• Grafik ve multimedya hizmetleri (Grafik ve Multimedya Hizmetleri).
• Mesajlaşma ve işbirliği (Mesajlaşma ve İşbirliği).
• Ağ oluşturma.
• Ağ hizmetleri.

Windows API'nin açıklaması, Windows Software Development Kit (SDK) belgelerinde bulunabilir. Bu belgeler www.msdn.microsoft.com adresinde mevcuttur. Ayrıca, geliştiricilere ayrılmış Microsoft Developer Network (MSDN) üzerindeki tüm abonelik seviyelerine dahildir.

Microsoft .NET Framework, Framework Sınıf Kitaplığı (FCL) adlı bir sınıf kitaplığından ve yönetilen bir Ortak Dil Çalışma Zamanı (CLR) kod çalıştırma zamanından oluşur. CLR, tam zamanında derleme, tip denetimi, çöp toplama ve kod erişim güvenliği özelliklerine sahiptir. CLR, bu özellikleri sunarak programcı üretkenliğini artıran ve en yaygın programlama hatalarını azaltan bir geliştirme ortamı sağlar.

CLR, kodu kullanıcı modunda çalışmak üzere tasarlanmış standart bir Windows DLL'de bulunan klasik bir COM sunucusu olarak uygulanır. Neredeyse tüm .NET Framework bileşenleri, yerel Windows API işlevlerinin üzerine yerleştirilmiş standart Windows kullanıcı modu DLL'leri olarak uygulanır. (.NET Framework bileşenlerinin hiçbiri çekirdek modunda çalışmaz.) Bu bileşenler arasındaki ilişki şekilde gösterilmiştir.

Hizmetler, işlevler ve standart programlar.

Windows kullanıcı ve programlama belgelerindeki bazı terimler, farklı bağlamlarda farklı anlamlara sahiptir. Örneğin, hizmet sözcüğü işletim sisteminde, bir aygıt sürücüsünde veya bir hizmet sürecinde çağrılan bir yordamı ifade edebilir. Bu terimlerin tam olarak ne anlama geldiği aşağıdaki listede gösterilmektedir:

• Windows API İşlevleri. Windows API'de belgelenmiş, çağrılabilir alt programlar. Örneğin, CreateProcess, CreateFile ve GetMessage.
• Yerel sistem hizmetleri (veya sistem çağrıları). Kullanıcı modunda çalışırken çağrılan işletim sistemindeki belgelenmemiş çekirdek hizmetler. Örneğin, NtCreateUserProcess, Windows CreateProcess işlevinin yeni bir işlem oluşturmak için çağırdığı dahili bir hizmettir.
• Çekirdek destek işlevleri (veya alt programlar). Windows işletim sisteminde yalnızca çekirdek modundan çağrılabilen alt programlar. Örneğin, ExAllocatePoolWithTag, Windows sisteminin dinamik olarak ayrılmış alanlarından (havuzlar olarak adlandırılır) bellek ayırmak için aygıt sürücüleri tarafından çağrılan bir yordamdır.
• Windows Hizmetleri. Hizmet Denetim Yöneticisi (Windowsservicecontrolmanager) tarafından başlatılan işlemler. Örneğin, Görev Yöneticisi hizmeti at komutunu destekleyen bir kullanıcı modu işlemi olarak çalışır (UNIX at veya cron komutlarına benzer).
• DLL kitaplıkları (dinamik bağlantı kitaplıkları - dinamik olarak bağlı kitaplıklar). Bu yordamları kullanan uygulamalar tarafından dinamik olarak yüklenebilen ikili bir dosya olarak birbirine bağlanan bir dizi çağrılabilir yordam. Örnekler arasında Msvcrt.dll (C ile yazılmış uygulamalar için bir çalışma zamanı kitaplığı) ve Kernel32.dll (Windows API alt sistem kitaplıklarından biri) yer alır. DLL'ler, kullanıcı modunda çalışan Windows bileşenleri ve uygulamaları tarafından yaygın olarak kullanılır. DLL'lerin statik kitaplıklara göre sağladığı avantaj, aynı anda birden çok uygulama tarafından kullanılabilmesidir ve Windows, DLL'ye başvuran uygulamalar için DLL kodunun yalnızca bir kopyasının bellekte tutulmasını sağlar. Yürütülemeyen .NET derlemelerinin DLL'ler olarak derlendiğini, ancak dışa aktarılan yordamlar olmadan derlendiğini unutmayın. CLR, uygun türlere ve sınıf üyelerine erişmek için derlenmiş meta verileri ayrıştırır.

Win32 API'sinin Tarihçesi.

İlginç bir şekilde, Win32, o zamanlar Windows NT olarak bilinen şey için orijinal programlama arabirimi olarak tasarlanmamıştı. Windows NT projesi, OS/2 sürüm 2'nin yerini alacak şekilde başladığından, orijinal programlama arabirimi 32-bit OS/2 PresentationManagerAPI idi. Ancak projenin lansmanından bir yıl sonra satışa çıkan Microsoft Windows 3.0 havalandı. Sonuç olarak, Microsoft yön değiştirdi ve Windows NT'yi, OS/2 yerine Windows ürün ailesi için gelecekteki ikame yaptı. Bu bağlamda, Windows API için bir özellik geliştirmek gerekli hale geldi - bundan önce, Windows 3.0'da API yalnızca 16 bitlik bir arayüz biçiminde mevcuttu.

Windows API'nin Windows 3.1'de bulunmayan birçok yeni özelliği sunması amaçlanmış olsa da, Microsoft, mevcut taşıma yükünü hafifletmek için yeni API'yi 16 bit Windows API ile mümkün olduğunca adlandırma, anlamsal ve veri türü uyumlu hale getirmeye karar verdi. 16-bit Windows.-Windows NT'deki uygulamalar. Aslında bu, birçok işlev ve arayüz adının tutarsız görünebileceğini açıklıyor: bu, yeni Windows API'sinin eski 16 bit Windows API ile uyumluluğunu sağlamak için gerekliydi.

API (Application Programming Interface), yazılım geliştiricileri tarafından sıklıkla bahsedilen bir terim olan bir uygulama programlama arayüzüdür. Geliştirmekte olduğunuz uygulamanın diğer uygulamalardan erişmenizi sağlayan bir özelliği varsa, bu uygulamanızın API'sidir. İşlevinizin API'sini oluşturan parametreler, diğer uygulamaların işlevle etkileşime girdiği araçlardır.

Windows işletim sistemi, Visual FoxPro uygulamaları da dahil olmak üzere çeşitli uygulamaların Windows ile oldukça düşük düzeyde iletişim kurmasına izin veren geniş bir özellik seti sağlar. Bu işlevler genellikle Windows API olarak adlandırılır. Visual FoxPro uygulamalarında Windows API'sini kullanmak, standart dil araçlarıyla elde edilemeyen özellikleri uygulamanıza olanak tanır.

Visual FoxPro'da Windows API İşlevlerini Bildirme

Windows API işlevleri, dinamik olarak bağlantılı kitaplıklara (Dynamic Link Library, DLL). Kural olarak, bu tür kitaplıkların dosyaları şu uzantıya sahiptir: dll. Uygulamanızda bir Windows API işlevini kullanmadan önce şunları yapmalısınız: duyurmak. DECLARE..DLL komutu, bir işlevi bildirmek için kullanılır:

İLAN ETMEK[ cFonksiyonTürü] Fonksiyon adıİÇİNDE KitaplıkAdı ; [cParamType1 [@] ParametreAdı1, cParamType2 [@] ParametreAdı2, ...]

Komut seçenekleri:

cFonksiyonTürü
isteğe bağlı parametre, işlev tarafından döndürülen veri türünü belirtir:

Fonksiyon adı
DLL'deki işlevin adı. İşlev adı büyük/küçük harfe duyarlıdır, yani GetDC ve GETDC tamamen farklı işlev adlarıdır.

KitaplıkAdı
işlevi içeren DLL'nin adı. Kernel32.dll, Gdi32.dll, User32.dll, Mpr.dll ve Advapi32.dll kitaplıkları için WIN32API eşanlamlısını kullanabilirsiniz.

Takma ad
isteğe bağlı parametre, işlev adı yerine kendi takma adınızı kullanmanıza olanak tanır. Diğer adın yazımı, işlev adından farklı olarak büyük/küçük harfe duyarlı değildir. Tipik olarak, işlevin API adı yerleşik (veya sizin) Visual FoxPro işlevinizin adıyla eşleştiğinde bir takma ad kullanılır.

cParamTürü
işleve iletilen değerin veri türünü belirtir:

Parametre hem değere hem de referansa göre iletilebilir. "@" karakteri, bir parametrenin referans olarak iletildiğini belirtmek için kullanılır.

Visual FoxPro açısından Uzun ve Tamsayı veri türleri arasında fark yoktur. Tipik olarak, Tamsayı türü, işaretli tamsayıları temsil etmek için kullanılır ve Long türü, işaretsiz tamsayıları temsil etmek için kullanılır.

ParamAdı
isteğe bağlı parametre, tamamen tanımlayıcıdır ve genellikle göz ardı edilir.

Windows API'nin tüm işlevleri ve Windows'un kendisi C programlama dilinde yazılmıştır. Bu nedenle, Visual FoxPro'da API işlevlerinin nasıl doğru kullanılacağını anlamak için (bu arada, en azından çekirdeği C'de de yazılmıştır), C ve Windows'ta hangi veri türlerinin kullanıldığını öğrenelim ve , daha az önemli değil, numaralandırmalar, yapılar ve işaretçiler gibi veri türlerini ele alalım. Ek olarak, C'de hangi fonksiyon prototiplerinin olduğunu ve MSDN'deki bir fonksiyon prototipinin açıklamasına dayanarak, onu DECLARE..DLL komutunda nasıl doğru şekilde bildireceğinizi öğreneceksiniz.

Temel C Veri Türleri

C programlama diline aşina iseniz, içinde çeşitli veri türlerini oluşturmanın ne kadar kolay olduğunu bilirsiniz. Aşağıdaki kodu yazmanız yeterlidir:

Typedef int INT32;

ve burada int tipine tamamen karşılık gelen yeni bir INT32 tipine sahipsiniz. Ancak C'nin bakış açısına göre bunlar tamamen farklı türlerdir ve INT32 türünde bir değişkeni int türünde bir değişkene atamaya çalışmak hatayla sonuçlanacaktır!

Veri türlerinin bolluğu, birçok geliştiricinin API programlamanın zor olduğunu düşünmesine neden olur. Ama değil! C'de, esas olarak aşağıdaki veri türleri kullanılır:

tip karakter - ANSI formatında karakter. 8 bit uzunluğundadır (bir bayt).

tip wchar - Unicode formatında karakter. 16 bit uzunluğundadır (iki bayt).

tip int - bütün sayılar. C'de üç tipe ayrılırlar: int, kısa int Ve uzun int. İkincisi genellikle kısaltılır kısa Ve uzun. Tip kısa 16 bittir ve türleri int Ve uzun- 32 bitlik tamsayılar.

tip batmadan yüzmek kesirli kısmı olan gerçek sayılardır. 32 bit (4 bayt) uzunluğundadırlar.

tip çift- gerçek çift kesinlik sayıları. 64 bit (8 bayt) uzunluğundadırlar.

tip Sıralama - numaralandırılmış veri türü.

tip geçersiz uzunluğu sıfır olan ve değeri olmayan nicelikleri belirtmek için kullanılır.

tip Işaretçi - Işaretçi; diğer C türleri gibi geleneksel anlamda bilgi içermez; bunun yerine her işaretçi, gerçek verilerin depolandığı bellek konumunun adresini içerir. 32 bit (4 bayt) uzunluğundadır.

İşin garibi, C'de string tipi yok. Aslında, tüm diziler C'de karakter dizileri olarak temsil edilir.

Bazı türler imzasız olarak bildirilebilir. Değiştirici imzasız (işaretsiz), aşağıdaki veri türleri ile kullanılır: karakter, kısa, int Ve uzun.

Örneğin, C'deki aşağıdaki değişken bildirimi:

imzalı int değişken ismi;

bu değişkenin işaretsiz 32 bitlik bir tam sayı olduğu anlamına gelir.

Değiştirici sabit belirtilen türdeki bir değişkenin sabit olduğunu, yani değerinin değiştirilemeyeceğini belirtir.

Numaralandırılmış tür Sıralama numaralandırılmış sabitler adı verilen bir dizi adlandırılmış sabiti bir değişkenle ilişkilendirir. Numaralandırılmış bir tür bildirimi şuna benzer:

Sıralama etiket_alanı { const1, const2, ... } değişken;

Eğer etiket_alanı atlanırsa, kapanış kaşlı ayraçtan sonra belirtmeniz gerekir değişken. Eğer etiket_alanı belirtilmiş, sonra gösterilmemiş değişken.

Tarihsel olarak, enum türü int türüne eşdeğerdir - yani numaralandırılmış bir tür değişkeni bellekte 4 bayt yer kaplar. Numaralandırılmış her sabit, listedeki seri numarası tarafından belirlenen bir değere sahiptir; numaralandırma sıfırdan başlar. CombineMode sıralamasını göz önünde bulundurun:

Enum CombineMode( CombineModeReplace, CombineModeIntersect, CombineModeUnion, CombineModeXor, CombineModeExclude, CombineModeComplement );

Bu numaralandırmada, CombineModeReplace sabiti 0 değerine, CombineModeIntersect sabiti 1 değerine sahiptir vb. CombineModeComplement sabiti 5'tir.

Numaralandırılmış sabitlerin değerleri, aşağıdaki örnekte olduğu gibi açıkça belirtilebilir:

Enum DashCap( DashCapFlat = 0, DashCapRound = 2, DashCapTriangle = 3 );

Listelenen veri türleri, Windows API programlamasında kullanılan tüm veri türlerinin %99'unu kapsar. Kulağa çok kolay geliyor, değil mi? API işlevlerinin açıklamaları neden tüm bu türleri içerir - HWND, HINSTANCE, POINT ve benzerleri?

Bunun nedeni, C'nin adında bir özelliği olmasıdır. katı yazım. Aynı türden bir değişken bir kez tanıtıldığında, yalnızca türüne uyan değerleri alabilir. Bir diziyi önce bir değişkende saklayıp sonra ona bir sayı atayamazsınız. Visual FoxPro'da genellikle bunu adlandırma kuralları aracılığıyla simüle etmeye çalışırız. Örneğin, cName bir karakter tipi değişkeni iken nCount sayısal bir tiptir. sıkı yazım varolan bir veri tipine yeni bir isim vererek yeni bir veri tipi oluşturmanıza olanak sağlar. Her yeni tür, aynı şeyi dahili olarak depolasalar da, diğer türlerden farklı görünmektedir.

Windows bu kavramın kullanımını zorlaştırır. Örneğin, LONG türü aslında uzun bir int iken, UINT türü aslında unsigned bir int'dir. Her iki tür de 32 bitlik tam sayılardır. Türetilmiş veri türleri, çeşitli içerme dosyalarında (.h uzantılı dosyalar) tanımlanır. Visual Studio .NET'i satın aldıysanız, bu dosyaları klasörde bulabilirsiniz. ..\VC7\PlatformSDK\Dahil Et\.

Windows veri türleri

Bir API işlevinde kullanılan veri türünü gerçekten temsil eden C temel türlerinden hangisinin belirlenmesi, API programlamadaki en zor görevlerden biridir. Şu kuralı kullanın: bir kelime bulamazsanız kayan nokta, çift, char veya str bir işlev veya parametre adının herhangi bir yerindeyse, genellikle 32 bitlik bir tamsayıdır. Becerileri anlamak ve geliştirmek biraz zaman alacaktır, ancak daha sonra veri türlerini kolayca dönüştüreceksiniz. Aşağıdaki tablo, Visual FoxPro'da bir işlev bildirirken kullanılan ana Windows veri türlerini ve bunlara karşılık gelen türleri listeler:

İşaretçiler

C'de yaygın olarak kullanılan bir başka kavram da işaretçilerdir. İşaretçi, verilerin depolandığı bir bellek alanının adresini içeren bir değişkendir. İşaretçinin türü her zaman işaret ettiği veri türüne göre belirlenir; boyutu her zaman dört bayttır. Örneğin, SHORT türündeki bir değişkene yönelik bir işaretçi, diğer herhangi bir veri türüne yönelik bir işaretçi gibi, 32 bitlik bir tamsayıdır. Windows API programlamasında kullanılan işaretçi açıklaması, 32 bit bellek modeliyle çalışan Uzun İşaretçi veya "uzun işaretçi" anlamına gelen "LP" karakterleriyle başlar. Ardından, verilerin değiştirilmemesi gerektiğini belirten "C" (const) karakteri gelebilir. Aşağıda, adresi işaretçide saklanan değişkenin veri tipinin açıklaması yer almaktadır. Örneğin, LPDWORD, bir DWORD değişkenine işaretçidir.

Sayısal verilere yönelik işaretçiler, bir Windows API işlevi bildirilirken referans olarak iletilir. Örnek olarak, GetFileSize işlevini düşünün. İşte prototipi (aşağıda fonksiyon prototipleri hakkında daha fazla bilgi):

DWORD GetFileSize(HANDLE hFile, // dosya tanıtıcısı LPDWORD lpFileSizeHigh // işaretçi);

İşleve iletilen ikinci parametre, işlevin dosya boyutu değerini bayt cinsinden yerleştireceği bir DWORD değişkeninin işaretçisidir.

Visual FoxPro'da bu işlevin bildirimi şöyledir:

WIN32API'DE GetFileSize BİLDİRİN Uzun hFile, Uzun @ FileSizeHight

Gördüğünüz gibi FileSizeHight parametresi fonksiyona aktarılıyor. bağlantı, çünkü referansa göre geçmek sadece bir işaretçiyi geçmektir.

Dizilerde durum daha karmaşıktır. Daha önce belirtildiği gibi, C'deki karakter dizileri dizilerdir, bu nedenle API işlevlerini programlamada, tür str CHAR türünde bir karakter dizisini tanımlayan (sırasıyla, tür wstr WCHAR türünde bir karakter dizisini tanımlar). Aşağıdaki tabloda, karakter dizilerine yönelik işaretçi türleri gösterilmektedir:

Karakter verilerine yönelik işaretçiler, başvuruya veya değere göre geçirilebilir - Visual FoxPro'daki bir işlev bildirimindeki Dize türü her zaman bir işaretçi geçer karakter verilerini içeren bir değişkene. Yalnızca bir API işlevinin bir parametrenin değerini değiştirmesi gerektiğinde referans olarak geçen karakter verilerini kullanın.

yapılar

Bir yapı, tek bir bütün oluşturan çeşitli türlerdeki değişkenler kümesi olarak görülebilir. C'de, anahtar kelime kullanılarak bir yapı oluşturulur. yapı ardından isteğe bağlı etiket alanı(etiket) ve liste elementler yapılar:

yapı etiket_alanı { eleman_türü eleman1; eleman_türü eleman2; ..... eleman_türü elemanN; };

Bunun gibi bir yapı bildirmek de mümkündür:

yapı( eleman_türü eleman1; eleman_türü eleman2; ..... eleman_türü elemanN; } değişken;

Bu reklam eksik etiket alanı ve sözde anonim bir yapısal tip yaratılır; bu sözdizimi, aşağıdaki örnekte olduğu gibi, bir veya daha fazla değişkeni bu yapı türüyle ilişkilendirmenizi sağlar:

Yapı( KELİME yıl; KELİME wAy; KELİME Haftanın Günü; KELİME gün; KELİME saat; KELİME wDakika; KELİME wİkinci; KELİME wMilisaniye; ) SİSTEM ZAMANI, * SİSTEM ZAMANI;

Yapılar, Visual FoxPro tablo girişlerine çok benzer. Yani, eğer tablo girişi kişisel alanları içerir fio,adres,tlfnumarası ve e-posta, ardından tlfnumber alanına erişmek için aşağıdaki sözdizimi kullanılır:

Personal.tlfnumber

Yapının alanına erişim aynı şekilde görünür:

SYSTEMTIME.wMinute

Visual FoxPro, yapıları oluşturmak için karakter dizeleri içeren değişkenleri kullanır. Örneğin, yukarıda tartışılan SYSTEMTIME yapısı için 16 baytlık bir değişkene ihtiyacınız olacaktır. Bu değişkenin ilk iki baytı, alanın değerini içerir. yıl, sonraki iki baytta - alanın değeri wAy, sonraki iki baytta - alanın değeri Haftanın Günü, vb., yapı tamamen oluşana kadar. Ve Visual FoxPro'da bir API işlevi bildirirken, yapıyı içeren değişkenin geçirildiği parametrenin türü String türünde olmalıdır. Bir dizi değişkenine sayısal veri yazmayı biraz sonra öğreneceksiniz.

Windows API'sini C'de programlarken, bir yapının işaretçisinin açıklaması LP (Uzun İşaretçi) karakterleriyle başlar ve ardından yapının adı gelir. Bu nedenle, SYSTEMTIME yapısına işaretçi LPSYSTEMTIME türünde olacaktır, POINT yapısına işaretçi LPPOINT türünde olacaktır, vb. Gördüğünüz gibi, karmaşık bir şey yok, ancak bu konsept sayesinde, yapılara yönelik son derece fazla sayıda işaretçi türü var.

Aktarılan yapıdaki verilerin değişmemesi gerekiyorsa, böyle bir yapıya işaretçi aşağıdaki gibi bildirilir:

YAPI yapı_adı *

Burada CONST değiştiricisi, yapıdaki verilerin değişmemesi gerektiği anlamına gelir ve yapı adından sonraki simge (*), bu satırın tamamının yapıya bir işaretçi açıklaması olduğu anlamına gelir. Aşağıdaki örnek, bir yapıyı diğerine kopyalayan CopyRect işlevinin prototipini gösterir:

BOOL CopyRect(LPRECT lprcDst, DOĞRU YAPI * lprcSrc);

MSDN'deki İşlev Prototiplerinin Açıklaması

Artık veri türleriyle ilgili her şey aşağı yukarı netleştiğine göre, fonksiyon prototipleri gibi bir C konseptine daha yakından bakalım.

ANSI standardına göre, C'deki tüm fonksiyonların prototipleri olmalıdır. İşlev prototipi oldukça basittir:

Prototip, VOID türünü şu şekilde belirtirse dönüş_türü, işlevin herhangi bir değer döndürmediği anlamına gelir. VOID türü olarak belirtilirse parametre_türü, işlevin parametresi olmadığı anlamına gelir.

Visual Studio.NET için MSDN'deki Kernel32.dll, Gdi32.dll, User32.dll, Mpr.dll ve Advapi32.dll kitaplıklarında yer alan Windows API işlevlerinin prototipleri hakkında bilgileri aşağıdaki yardım konularını açarak bulabilirsiniz. sipariş: :

MSDN Kitaplığı

Windows Geliştirme Win32 API SDK Documentacion Referansı

Referans bölümünde, aşağıdaki alt bölümlerden birini açarak işlevlerin açıklamalarını görüntüleyebilirsiniz:

API işlevleri hakkında da bilgi içeren MSDN'deki başka bir adres:

MSDN Kitaplığı

Kullanıcı Arayüzü Tasarımı ve Geliştirme SDK Documentacion Windows Kabuğu Kabuk Referansı Kabuk İşlevleri

Aşağıdaki şekilde, MSDN Yardım penceresinin bir parçası gösterilmektedir:

Örneğin, CopyRect işlevinin MSDN'de nasıl açıklandığı aşağıda açıklanmıştır:

KopyalaRect

bu KopyalaRect fonksiyon bir dikdörtgenin koordinatlarını diğerine kopyalar.

BOOL CopyRect(
LPRECT lprcDst, // hedef dikdörtgen
YAPI DOĞRU* lprcSrc// kaynak dikdörtgen
);

parametreler

lprcDst
İşaretçi DOĞRUDAN kaynak dikdörtgenin mantıksal koordinatlarını alan yapı.
lprcSrc
Koordinatları mantıksal birimler halinde kopyalanacak olan RECT yapısının işaretçisi.

Dönüş Değerleri

İşlev başarılı olursa, dönüş değeri sıfır değildir.
İşlev başarısız olursa, dönüş değeri sıfırdır.
Windows NT/2000/XP: Genişletilmiş hata bilgilerini almak için GetLastError'u arayın.

Notlar

Uygulamalar dikdörtgenleri farklı amaçlar için kullanabildiğinden, dikdörtgen işlevleri açık bir ölçü birimi kullanmaz. Bunun yerine, tüm dikdörtgen koordinatları ve boyutları işaretli, mantıksal değerlerle verilir. Eşleme modu ve dikdörtgenin kullanıldığı işlev ölçü birimlerini belirler.

Örnek Kod

Bir örnek için bkz. Dikdörtgenleri Kullanma.

Gereksinimler

Windows NT/2000/XP: Windows NT 3.1 ve sonrasında dahildir.
Windows 95/98/Me: Windows 95 ve sonrasında dahildir.
Başlık: Winuser.h'de bildirildi; Windows.h'yi içerir.
Kitaplık: User32.lib kullanın.

Gördüğünüz gibi, bilgiler oldukça ayrıntılı. İşlev, BOOL türünde bir değer döndürür, ona iki parametre iletilir: LPRECT türü ve CONST RECT* - RECT türündeki yapılara işaretçiler. Visual FoxPro'da bu işlevi bildirirken, ilk parametrenin başvuruya göre ve ikinci parametrenin değere göre iletildiğini belirtmeniz gerekir:

Uzun CopyRect IN User32.dll String @ DECLARE Dst, Sicim kaynak

Ve bu işlevin User32.dll kitaplığında olduğunu nasıl belirledim? Çok basit. Tavsiye bölümünde ( Gereksinimler) Kitaplık yan tümcesinde Use User32.lib yazıyor. Uzatma yerine lib eklenti dll- ve bu kadar! Bu arada aynı yerde Header paragrafında fonksiyon prototipinin açıklamasının hangi include dosyasında yer aldığı bildiriliyor.

Ama hepsi bu değil! İşlev yapılarla çalıştığından, açıklaması RECT yapısına bir köprü içerir. Bu köprüye tıklayın ve yapının ayrıntılı bir açıklaması ekranda görünecektir.

Visual FoxPro'da Yapıları Şekillendirme

Visual FoxPro'nun dokuzuncu sürümü, yerleşik BINTOC ve CTOBIN işlevlerini büyük ölçüde geliştirir. Bu işlevler artık sayısal verileri yapılarda kullanıma uygun bir biçime dönüştürmek için kullanılabilir. BINTOC işlevinin bir sayıyı bir diziye dönüştürdüğünü ve CTOBIN işlevinin bir dizeyi bir sayıya dönüştürdüğünü hatırlatmama izin verin.

BINTOC işlevinin sözdizimi:

BINTOC( nİfade, eBayrak)

Parametrenin alabileceği tüm olası değerlerden eBayrak, aşağıdakilerle ilgileniyoruz:

CTOBIN işlevinin sözdizimi şöyledir:

CTOBİN(c ifade, eBayrak)

Olası parametre değerleri eBayrak:

Aşağıda, bu işlevlerin kullanımına ilişkin örnekler gösterilmektedir:

CTOBIN(BINTOC(1000.55,"4RS"), "4RS") && Sonuç: 1000 ? CTOBIN(BINTOC(-1000.55,"4RS"), "4RS") && Sonuç: -1000 ? CTOBIN(BINTOC(1000.55,"F"), "4N") && Sonuç: 1000.549987929 ? CTOBIN(BINTOC(-1000.55,"F"), "4N") && Sonuç: -1000.549987929 ? CTOBIN(BINTOC(1000.55,"B"), "8N") && Sonuç: 1000.55 ? CTOBIN(BINTOC(-1000.55,"B"), "8N") && Sonuç: -1000.55

Örnek olarak bir Visual FoxPro değişkenine RECT yapısı yazalım. Bu yapı, daha önce tartışılan CopyRect işlevinde dikdörtgen bir alanın koordinatlarını tanımlamak için kullanılır. Bu yapı MSDN'de şu şekilde açıklanmaktadır:

Typedef struct _RECT ( UZUN sol; UZUN üst; UZUN sağ; UZUN alt; ) RECT, *PRECT;

Gördüğünüz gibi, RECT yapısı her biri LONG değerini saklayan dört alan içerir. Visual FoxPro'da oluşturmak için 16 baytlık bir dizeye ihtiyacınız var.

Aşağıda, CopyRect işlevini bildiren, Dst ve Src yapılarını oluşturarak bunları işleve parametre olarak ileten ve ardından bir yapıyı diğerine kopyalayan kod bulunmaktadır. Örnek, bir sayıyı dizgeye dönüştürmek için BINTOC işlevini kullanır:

DECLARE Uzun CopyRect IN WIN32API String @ Dst, String Src * Form Src yapısı cSrc = BINTOC(nLeft,"4RS") + BINTOC(nTop,"4RS") + ; BINTOC(nRight,"4RS") + BINTOC(nBottom,"4RS") * Dst yapısı için yer hazırlayın cDst = REPLICATE(CHR(0),16) nResult = CopyRect(@cDst, cSrc) && Kopyala

Aşağıdaki örnek, CTOBIN işlevini kullanarak bir yapıyı, alanlarının sayısal değerlerini alarak nasıl "ayrıştırabileceğinizi" gösterir:

NLeft = CTOBIN(SUBSTR(cDst,1,4), "4RS") && RECT.left nTtop = CTOBIN(SUBSTR(cDst,5,4), "4RS") && RECT.top nRight = CTOBIN(SUBSTR(cDst, 9,4), "4RS") && RECT.right nBottom = CTOBIN(SUBSTR(cDst,13,4), "4RS") && RECT.bottom

İşaretçiler içeren yapılar

Çoğu zaman, Windows API işlevine aktarılan yapının işaretçiler içerdiği bir durum vardır. Örnek olarak, bir yazıcıda yazdırılmak üzere bir belge oluşturan StartDoc işlevini düşünün. İşte onun prototipi:

Int StartDoc(HDC hdc, // DC CONST DOCINFO'yu yönet* lpdi// dosya adlarını içerir);

Gördüğünüz gibi fonksiyona iletilen ikinci parametre bir DOCINFO yapısına işaretçidir. İşte yapı:

Typedef yapısı ( int cbBoyutu; LPCTSTR lpszDocName; LPCTSTR lpszÇıktı; LPCTSTR lpszVeri türü; DWORD fwTürü; ) DOCINFO, *LPDOCINFO;

Yapının ilk alanı, cbBoyutu, yapının bayt cinsinden uzunluğunu içerir. Ancak sonraki üç alan, karakter verilerini içeren değişkenlere yönelik işaretçilerdir. Özellikle, alan lpszDocName içerir Işaretçi yazdırılacak belgenin adının bulunduğu satırda (bu, yazdırılacak belge sırasını görüntülerken gördüğünüz belge adının aynısıdır).

Visual FoxPro'da işaretçiler içeren bir yapı oluşturmak oldukça zordur. Öncelikle, bir bellek bloğu ayırmanız ve ona bir işaretçi almanız gerekir. İkinci olarak, Visual FoxPro değişkeninin değerini bu belleğe yeniden yazmak gerekiyor - böylece tam olarak uygulanmış bir işaretçi mekanizmasına sahip olacağız. Yapılacak son şey, işaretçinin değerini bir yapıya koymaktır. Bu durumda, temel bir gereksinim karşılanmalıdır: tahsis edilen hafızanın yeri değiştirilemez - aksi takdirde, işaretçimiz bir noktada verilerimizin hiçbir ilgisi olmayan bir alanı işaret edebilir!

Bir bellek bloğu elde etmek için birkaç olasılık vardır. Hem Windows'un genel belleğinden hem de işleme ayrılan bellekten (yani uygulamanız) bir "parça" alabilirsiniz. İkinci yöntem daha yüksek bir performansa sahiptir, ancak burada Windows belleğiyle çalışma yöntemini daha basit olarak ele alacağız.

GlobalAlloc işlevi, Windows'tan belirtilen boyutta bir bellek bloğu alır ve ona bir işaretçi döndürür. İşte bu fonksiyonun prototipi:

HGLOBAL GlobalAlloc(UINT u Bayraklar, // bellek ayırma öznitelikleri SIZE_T dwBytes// bayt cinsinden boyut);

Parametre u Bayraklar belleğin nasıl ayrılacağını belirler. MSDN, aşağıdaki değerlerden birini alabileceğini söylüyor:

Tablodan, parametre için u Bayraklar GPTR değeri kullanılmalıdır. Ama nasıl biliyorsun Hangi bu değer mi? GlobalAlloc işlevinin açıklaması için ve bölümünde MSDN'de arama yapın Gereksinimler hangi içerme dosyasının prototipini içerdiğini görün. Bu, Winbase.h dosyasıdır. Sabitlerin değerlerinin bir tanımını araması gereken yer burasıdır. İşte tabloda listelenen sabitleri tanımlayan bu dosyanın bir parçası:

/* Global Memory Flags */ #define GMEM_FIXED 0x0000 #define GMEM_MOVEABLE 0x0002 #define GMEM_NOCOMPACT 0x0010 #define GMEM_NODISCARD 0x0020 #define GMEM_ZEROINIT 0x0040 #define GMEM_MODIFY 0x0080 #define GMEM_DISCARDABLE 0x0100 #define GMEM_NOT_BANKED 0x1000 #define GMEM_SHARE 0x2000 #define GMEM_DDESHARE 0x2000 #define GMEM_NOTIFY 0x4000 #define GMEM_LOWER GMEM_NOT_BANKED #define GMEM_VALID_FLAGS 0x7F72 #define GMEM_INVALID_HANDLE 0x8000 #define GHND (GMEM_MOVEABLE | GMEM_ZEROINIT) #define GPTR (GMEM_FIXED | GMEM_ZEROINIT)

Bu nedenle, GPTR = GMEM_FIXED + GMEM_ZEROINIT = 0x0000 + 0x0040 = 0x0040.

Ayrılan bellek bloğunun boyutu nedir? Tabii ki, belgenin adını saklayan dizenin uzunluğuna eşit. Aşağıdaki örnek, bir API işlevi bildirmekten bir bellek bloğu ayırmaya kadar olan adımları gösterir:

u Bayraklar, Uzun dwBytes cDocumentName = "Yazdırılacak belgenin adı" && Belge adı nLenDocumentName = LEN(cDocumentName) && Dize uzunluğu hGlobal = GlobalAlloc(GPTR, nLenDocumentName)

Bir sonraki görev, cDocumentName değişkeninin içeriğini ortaya çıkan bellek bloğuna yeniden yazmaktır. Bunun için Visual FoxPro SYS(2600) yerleşik işlevini kullanalım. Sözdizimi şöyledir:

SYS(2600, dwAdres, uzunluk [, cNewString])

İşlev, parametrenin belirtilip belirtilmemesine bağlı olarak farklı davranır. cNewString ya da değil.

parametre ise cNewString belirtildi, ardından işlev kopyalar uzunluk değişkenden bayt cNewString belirtilen adreste belleğe dwAdres.

parametre ise cNewString belirtilmemiş, ardından işlev geri döner uzunluk belirtilen adresteki bellekten bayt dwAdres.

Gördüğünüz gibi, parametre dwAdres- Bu Işaretçi.

GlobalAlloc işlevi tarafından ayrılan belleğe cDocumentName dizesinin içeriğini yazalım:

SYS(2600, hGlobal, nLenDocumentName, cDocumentName)

İşte DOCINFO yapısını oluşturmak için tam kod:

#DEFINE GPTR 0x0040 Uzun GlobalAlloc IN WIN32API Uzun DECLARE u Bayraklar, Uzun dwBytes cDocumentName = "Yazdırılacak belgenin adı" nLenDocumentName = LEN(cDocumentName) hGlobal = GlobalAlloc(GPTR, nLenDocumentName) SYS(2600, dwAdres, uzunluk [, cNewString]) * DOCINFO yapısını oluşturmaya başlama * cDocInfo, cDocInfo = BINTOC(20,"4RS") && DOCINFO yapısının oluşturulduğu bir değişkendir. cbBoyutu cDocInfo = cDocInfo + BINTOC(hGlobal,"4RS") && DOCINFO. lpszDocName cDocInfo = cDocInfo + REPLICATE(CHR(0),12) && Diğer yapı alanları * Yapı oluşturmanın sonu

Yapı bir değişkende oluşturulur cDocBilgisi. İlk dört bayta 20 sayısını yazıyoruz - bu, yapının boyutudur (alan cbBoyutu). Değişkene eklenen sonraki dört bayt, belgenin adı olan cDocumentName değişkeninin içeriğinin yeniden yazıldığı bellek alanına bir işaretçidir. Ardından değişkene on iki sıfır bayt daha eklenir - bunlar yapının alanlarıdır lpszÇıktı, lpszVeri türü Ve fwTürü belgelere göre göz ardı edilebilecek; bu, alanların boş değerlere sahip olması gerektiği anlamına gelir. Böylece, gerekli olan 20 bayt uzunluğunda bir dizi elde edildi.

Bellek kullanımının özellikleri

Uygulamalarınızda Windows API işlevlerini kullanırken, Visual FoxPro'nun bu işlevler tarafından ayrılan belleği yönetemeyeceğini bilmelisiniz. Bu nedenle, örneğin GlobalAlloc işlevini kullanarak bellek ayırırsanız, kullanımdan sonra GlobalFree işlevini çağırarak bu belleği Windows'a iade etmeniz gerekir. Belleği ayıran her API işlevi için, ayrılan belleği boşaltan bir antipode işlevi vardır.

İşte GlobalFree işlevinin prototipi:

HGLOBAL GlobalFree(HGLOBAL hMem // bellek bloğuna işaretçi);

İşlev yalnızca bir parametre alır - bir bellek bloğuna işaretçi. İşte Visual FoxPro'daki bildirimi ve kullanımı:

WIN32API'DE Long GlobalFree BİLDİRİN Long hGlobal GlobalFree(hGlobal)

burada hGlobal, GlobalAlloc işlevi tarafından döndürülen bellek bloğuna yönelik bir işaretçidir.

Tahsis edilen belleği iade etmeyi unutursanız, bellek sızıntısı adı verilen bir sorunla karşılaşma riskiyle karşı karşıya kalırsınız. Böyle bir sızıntının sonuçları, uygulamanızda bellek parçalanmasının neden olduğu keskin bir yavaşlamadan işletim sisteminin çökmesine kadar çok üzücü olabilir.

Bir dizi işlevine geçmek

Bir dizi, C'nin terimleriyle, aynı türden birden çok öğe içeren bir değişkendir. Dizinin her bir elemanına erişim, bir dizin kullanılarak gerçekleştirilir. Bir dizinin tüm öğeleri aynı boyuta sahiptir, dizileri karışık veri türleriyle tanımlayamazsınız. Tüm dizi öğeleri, ilk öğeye karşılık gelen minimum dizin değeri ve son öğeye karşılık gelen maksimum dizin değeri ile birbiri ardına bellekte saklanır.

Bir Visual FoxPro dizisi, öğelerinde tamamen farklı veri türlerini depolamanıza izin veren tamamen farklı bir organizasyona sahiptir. Bu nedenle, yalnızca adını bir parametre olarak sağlayarak Visual FoxPro'dan bir diziyi bir Windows API işlevine geçirmek mümkün değildir. Ayrıca DECLARE..DLL komutunda dizi diye bir veri türü yoktur.

Yine de, bu durumdan bir çıkış yolu var. Yapılarda olduğu gibi, dizileri geçirmek için karakter değişkenleri kullanılır. Dizideki sayısal veriler, Windows API işlevine parametre olarak ilettiğiniz bir dizeye dönüştürülmelidir. Aşağıdaki örnek, bir diziden bir dize oluşturan ArrayToString işlevinin kodunu gösterir. get işlevi bir dizi alır taArray(bağlantı) ve bayrak tlTypeOfValue, dizi öğelerinin değerlerinin tamsayı olarak nasıl dönüştürüleceğini gösterir ( tlTypeOfValue=.F.) veya gerçek ( tlTypeOfValue=.T.) numaraları:

İŞLEV ArrayToString PARAMETRELER taArray, tlTypeOfValue HARİCİ DİZİ taArray YEREL lnLenArray, lnIndex, lcStruct, lcType lcType = IIF(tlTypeOfValue = .t., "F", "4RS") lnLenArray = ALEN(taArray) && Dizideki öğe sayısı lcStruct = " " FOR lnIndex = 1 TO lnLenArray lcStruct = lcStruct + BINTOC(taArray, lcType) ENDFOR RETURN lcStruct ENDFUNC

İşlev, hem tek boyutlu hem de iki boyutlu dizilerle çalışır.

Karakter veri kodlaması: ANSI ve UNICODE formatları

ANSI kodlamasında (Visual FoxPro'da kullanılır), her karakter bir baytla tanımlanır, bu nedenle maksimum karakter sayısı 256'dır ve bu elbette çok küçüktür. Örneğin, Ruslaştırma sırasında bazı standart ANSI karakterleri Kiril karakterleri ile değiştirilir. Ve bazı alfabelerde, örneğin Japonca kana, o kadar çok karakter vardır ki, bir bayt onları kodlamak için yeterli değildir. Bu tür dilleri desteklemek ve daha da önemlisi programların diğer dillere "çevirisini" kolaylaştırmak için Unicode kodlaması geliştirildi. Unicode'daki her karakter, geçerli karakter kümesini 65536'ya genişletmeyi mümkün kılan iki bayttan oluşur.

Oldukça fazla sayıda Windows API işlevi, karakter dizileriyle çalışırken Unicode biçimini kullanır. Bu tür işlevlerle çalışmak için karakter verilerini bir biçimden diğerine dönüştürmek gerekir.

Yerleşik Visual FoxPro STRCONV işlevi, dizeleri hem ANSI'den UNICODE'a hem de tam tersine dönüştürür. Sözdizimi şöyledir:

STRCONV( cifade, nDönüşüm Ayarı [, nBölgesel Tanımlayıcı [, nBölgeselKimlikTürü]])

Parametre cifade dönüştürülecek dizedir. Parametre nDönüşüm Ayarı dönüşümün doğasını gösterir. Tüm olası değerlerinden yalnızca ikisiyle ilgileniyoruz:

• 5 - ANSI'den UNICODE'a dönüştürme
• 6 - UNICODE'dan ANSI'ye dönüştürme

İsteğe bağlı parametreler nBölgesel Tanımlayıcı Ve nBölgeselKimlikTürü ek bölgesel ayarlar tanımlayın ve güvenle göz ardı edilebilir.

Aşağıda, STRCONV işlevinin kullanımına ilişkin örnekler gösterilmektedir:

CUnicodeString = STRCONV(cANSIString, 5) && Unicode'a Dönüştür cANSIString = STRCONV(cUnicodeString, 6) && ANSI'ye Dönüştür

Bu bölümü okurken, Visual FoxPro'da Windows API işlevleriyle çalışmanın oldukça kolay olduğu izlenimine kapılmış olabilirsiniz. Evet ve hayır. Örneğin, bazı API işlevleri, DECLARE..DLL komutu tarafından desteklenmeyen 64 bitlik tamsayılar gibi veri türlerini kullanır. Geri arama işlevleri olarak adlandırılan bir dizi işlev de vardır. Böyle bir işlevin prototipinde, CALLBACK değiştiricisi, dönüş tipi bildiriminden önce bulunur. Ne yazık ki, bu tür işlevleri en azından doğrudan kullanamazsınız. Ayrıca, bir yapı bir işleve işaretçi içerir - bu tür API'ler Visual FoxPro'da da kullanılamaz.

API'nin kısaltması olan Uygulama Programlama Arayüzü (API), uygulama geliştiricilerin kullanabileceği bazı hazır işlevler kümesidir. Genel olarak, bu kavram, eskiden daha çok alt program kitaplığı olarak adlandırılan şeye eşdeğerdir. Bununla birlikte, çoğu zaman API, bu tür kitaplıkların bazı özel kategorilerini ifade eder.

Neredeyse tüm oldukça karmaşık uygulamaların (MyApplication) geliştirilmesi sırasında, son kullanıcı için MyApplication API adı verilen bu belirli programı uygulamak için kullanılan bir dizi özel dahili işlev oluşturulur. Genellikle bu işlevlerin, diğer programcılar tarafından da dahil olmak üzere başka uygulamalar oluşturmak için etkili bir şekilde kullanılabileceği ortaya çıktı. Bu durumda yazarlar, ürünlerini tanıtma stratejisine dayanarak, bu sete erişimi dış kullanıcılara açıp açmayacaklarına karar vermelidir? Olumlu bir yanıtla, yazılım paketinin açıklamasında, avantajı olarak, "kitin açık bir API işlevleri kümesi içerdiği" ifadesi görünür.

Bu nedenle, çoğu zaman bir API, bir uygulamanın parçası olan, ancak aynı zamanda diğer programlarda kullanılabilen bir dizi işlevi ifade eder. Örneğin, Excel, son kullanıcı arayüzüne ek olarak, özellikle VB kullanarak uygulamalar oluştururken kullanılabilecek bir dizi Excel API işlevine sahiptir.

Buna göre, Windows API, işletim sisteminin kendisinin bir parçası olan ve aynı zamanda başka herhangi bir uygulama tarafından kullanılabilen bir dizi işlevdir. Ve bu bağlamda, aslında bir DOS API'si olan BIOS / DOS sistem kesme seti ile benzetme oldukça haklı.

Aradaki fark, bir yandan Windows API işlevlerinin bileşiminin DOS'takinden çok daha geniş olması, diğer yandan bilgisayar kaynaklarının doğrudan yönetimi için mevcut olan araçların çoğunu içermemesi gerçeğinde yatmaktadır. önceki işletim sistemindeki programcılar. Ek olarak, Windows API'ye erişim, sıradan prosedür çağrıları kullanılarak gerçekleştirilir ve DOS işlevleri, işlemcinin Kesme ("kesme") adı verilen özel bir makine talimatı aracılığıyla çağrılır.

Win16 API'si ve Win32 API'si

Bildiğiniz gibi, Windows 3.x'ten Windows 95'e geçiş, 16 bit işletim sistemi mimarisinden 32 bit işletim sistemi mimarisine geçişi işaret ediyordu. Aynı zamanda, 16-bit Windows API'si (Win16 API) yeni bir 32-bit varyantı (Win32 API) ile değiştirildi. Bu durumda, birkaç istisna dışında Win32 API setinin Windows 9x ve Windows NT aileleri için aynı olduğunu aklınızda bulundurmanız yeterlidir.

Win API ile tanışırken, birçok yerleşik işlevin ilgili sistem prosedürlerine yapılan bir çağrıdan başka bir şey olmadığı, ancak yalnızca bu dilin sözdizimi biçiminde uygulandığı ortaya çıktı. Bu göz önüne alındığında, API'yi kullanma ihtiyacı aşağıdaki seçeneklerle belirlenir:

Tamamen yerleşik işlevler olarak uygulanan API işlevleri. Bununla birlikte, bazen bu durumda API'yi kullanmaya geçmek yararlıdır, çünkü bu bazen performansı önemli ölçüde artırabilir (özellikle, geçirilen parametrelerin gereksiz dönüşümlerinin olmaması nedeniyle).

Yerleşik işlevler, karşılık gelen API işlevinin yalnızca özel bir durumunu uygular. Bu oldukça yaygın bir seçenektir.

Çok sayıda API işlevinin, bugün var olan derleyici sürümünde hiçbir analogu yoktur. Örneğin, VB kullanarak bir dizini silemezsiniz - bunu yapmak için Dizini Sil işlevini kullanmanız gerekir.

Bazı API işlevlerinin (Win API'deki payları çok küçüktür), örneğin bellek adresleriyle çalışamama gibi bir dizi dil kısıtlaması nedeniyle programlardan çağrılamayacağı da vurgulanmalıdır. Ancak bazı durumlarda, önemsiz olmayan programlama teknikleri yardımcı olabilir (özellikle aynı adresler söz konusu olduğunda).

API kazanınVeDinamik Bağlantı Kitaplığı (DLL)

Win API seti, dinamik DLL'ler olarak uygulanır.

Bu durumda, DLL ile, uygulamaların gerekli prosedürlere - alt rutinlere veya işlevlere (bir proje içindeki prosedürleri çağırırken olduğu gibi) doğrudan erişimini sağlayan geleneksel ikili dinamik kitaplık varyantını kastediyoruz. Bu tür kitaplıklar farklı araçlar kullanılarak oluşturulabilir - VC++, Delphi, Fortran, Assembler.

Tipik olarak, dinamik kitaplık dosyaları .DLL uzantısına sahiptir, ancak bu hiç gerekli değildir. .EXE uzantısı genellikle Win16 için kullanılmıştır, harici aygıt sürücüleri .DRV ile belirtilmiştir.

Windows API'lerinin ve bunları içeren dosyaların tam sayısını belirlemek zordur (ancak hepsi sistem dizinindedir). Bu bağlamda, işletim sisteminin çekirdeğini oluşturan kitaplıkların ve önemli ek işlevlere sahip ana kitaplıkların bileşimini vurgulamak daha iyidir.

Windows 95/98 işletim sistemi çekirdeğinin Win32 API kitaplıkları:

KERNEL32.DLL: belleği, görevleri ve diğer sistem kaynaklarını yönetmek için alt düzey işlevler;

USER32.DLL: Kullanıcı arabirimi yönetim işlevlerinin çoğunun bulunduğu yer burasıdır;

GDI32.DLL: Grafik Aygıt Arabirimi kitaplığı - harici aygıtlara çeşitli çıktı işlevleri;

COMDLG32.DLL: Genel amaçlı iletişim kutularının kullanımıyla ilgili işlevler.

Uzantı işlevlerine sahip çekirdek kitaplıklar:

COMCTL32.DLL: Ağaç Listesi ve Zengin Metin dahil bir dizi ek Windows denetimi;

MAPI32.DLL: e-posta işlevleri;

NETAPI32.DLL: denetimler ve ağ işlevleri;

ODBC32.DLL: Bu kitaplığın işlevleri, ODBC protokolü aracılığıyla çeşitli veritabanlarıyla çalışmak için gereklidir;

WINMM.DLL: sistem ortamına erişim işlemleri.

BulPencere
GetWindow
GetWindowText
SetWindowText
Pencere
Pencereyi Taşı
Pencere Görünür mü
Pencereyi Etkinleştir
Pencere Etkin mi
PenceredenNoktadan
Pencere göster
Pencereyi kapat
SetWindowPos
GetClassLong
SınıfUzun Ayarla
GetWindowLong
Pencereyi Uzun Ayarla
GetDesktopWindow
GetParent

FindWindow işlevi

FindWindow(sınıfAdı,PencereAdı: PChar) işlevi: HWND;
İşlev, isteği karşılayan bir pencere tanıtıcısı döndürür (böyle bir pencere bulunamazsa 0).

Parametrelerden biri sıfıra eşit olabilir, bu durumda arama diğer parametreyi temel alır.
Örnek:

GetWindow işlevi

GetWindow(Wnd: HWND; Param) işlevi: HWND
İşlev, isteği karşılayan bir pencere tanıtıcısı döndürür.

Örnek:

GetWindowText İşlevi

işlev GetWindowText(hWnd: HWND; lpString: PChar; nMaxCount: Tamsayı): Tamsayı;
İşlev, pencere metnini döndürür. Bir form için bu, başlık olacaktır; bir düğme için, düğmenin başlığı olacaktır.

Metnin maksimum uzunluğu, eğer metin daha uzunsa kesilir.

Örnek:

IsWindow İşlevi

işlev IsWindow(hWnd: HWND): BOOL; Belirtilen tanıtıcıya sahip pencere varsa True, aksi halde False döndürür.

MoveWindow İşlevi

MoveWindow(hWnd: HWND; X, Y, nWidth, nHeight: Tamsayı; bRepaint: BOOL): BOOL; Pencereyi yeni bir konuma taşır.

IsWindowVisible İşlevi

işlev IsWindowVisible(hWnd: HWND): BOOL;
Belirtilen pencere görünür durumdaysa True değerini döndürür.

EnableWindow işlevi

EnableWindow(hWnd: HWND; bEnable: BOOL) işlevi: BOOL;
Pencerenin kullanılabilirliğini ayarlar (fare, klavye vb. olaylara yanıt vermiyorsa pencere kullanılamaz). Delphi'deki bir analog, Etkin bileşen özelliğidir. EnableWindow, her şey yolunda giderse True, aksi takdirde False döndürür.

Örnek:

IsWindowEnable işlevi

işlev IsWindowEnabled(hWnd: HWND): BOOL;
Belirtilen pencere için, pencere mevcutsa True, aksi takdirde False döndürür.

WindowFromPoint İşlevi

WindowFromPoint(Nokta: TPoint): HWND;
Ekranın bu noktasında pencereye bir tanıtıcı döndürür.

İşlev

ShowWindow İşlevi

işlev ShowWindow(hWnd: HWND; nCmdShow: Tamsayı): BOOL; Pencereyi gösterir veya gizler.

Örnek:

Pencereyi Kapat İşlevi

işlev CloseWindow(hWnd: HWND): BOOL; çağrı;
Pencereyi kapatır.

SetWindowPos

işlev SetWindowPos(hWnd: HWND; hWndInsertAfter: HWND; X, Y, cx, cy: Tamsayı; uFlags: UINT): BOOL; çağrı;
Pencereyi yeni bir konuma ayarlar

Buna göre - yeni ufuklar. , dikey pencere konumları ( X, Y), yanı sıra yeni genişlik
ve yükseklik ( cx, cy)

GetClassLong İşlevi

işlevi GetClassLong(hWnd: HWND; nIndex: Tamsayı): Tamsayı;
Bu işlev, kaydın belirli alanından alınan 32 bitlik bir tamsayı döndürür. TWndClassEx belirtilen pencere

Not: işlevin bir işaretçi döndürmesi durumunda, (Tamsayı ->

SetClassLong İşlevi

işlev SetClassLong(hWnd: HWND; nIndex: Tamsayı; dwNewLong: Longint): Tamsayı; Fonksiyonun çift fonksiyonu. Gerekli alanda karşılık gelen değeri ayarlar.
İşlev, daha sonra düzeltilebilmesi için alanın eski değerini döndürür veya bir şeyler ters giderse sıfır döndürülür.

Not Işaretçi yazmak tamsayı.

GetWindowLong İşlevi

GetWindowLong(hWnd: HWND; nIndex: Integer) işlevi: Longint; Bazı pencereler hakkındaki bilgileri 32 bit tamsayı olarak döndürür.

Not: işlevin bir işaretçi döndürmesi durumunda, tür atama gereklidir (Tamsayı -> İşaretçi). Bunu şu şekilde yapabilirsiniz:

SetWindowLong İşlevi

işlev SetWindowLong(hWnd: HWND; nIndex: Integer; dwNewLong: Longint): Longint;
Fonksiyona buhar . Belirli bir pencerenin niteliklerini değiştirir.
Çağrı başarılı olursa işlev, özelliğin eski değerini, aksi takdirde null değerini döndürür.

Not: işaretçi alanlarını ayarlarken, tip atama gereklidir Işaretçi yazmak tamsayı.

GetDesktopWindow İşlevi

GetDesktopWindow işlevi: HWND
İşlev, Masaüstü penceresine bir tanıtıcı döndürür. Parametreler olmadan.

GetParent

GetParent işlevi(hWnd: HWND): HWND;
Pencere için ana pencere tanıtıcısını döndürür hWnd.