Program FR4.exe (jádro) obsahuje všechny nezbytné části zajišťující připojení a obsluhu přídavných DLL modulů (tzv. plug-ins), jednotný souborový systém (nazývaný též projekt) pro všechny moduly, systém globálních parametrů a podporu grafiky.

Modulární uspořádání umožňuje konfigurovat program FR4 dynamicky pomocí popisu konfigurace v souboru FR4.ini (adresář WINDOWS).

Společný systém správy souborů (a dynamických polí) prováděný jádrem FR4 umožňuje, aby jednotlivé moduly byly volány v libovolném pořadí. Společná data pak slouží ke vzájemné komunikaci mezi moduly a k uchování postupu řešení problému. Při zastavení programu jsou soubory uloženy na disk a dynamická pole automaticky zrušena.

Další společnou datovou částí jádra jsou globální parametry, které mohou být čteny i zapisovány ze všech modulů a slouží k jednoduché komunikaci mezi moduly i definování stavových podmínek modulů, případně i k evidenci postupu prací. Popis globálních parametrů, které se váží na práci programu, je ukládán do souboru FR4.fpr. Parametry související jen s projektem pak do souboru project.fr4.

V první sekci souboru project.fr4 nazvané "Project parameters" jsou uloženy parametry související s konkrétním projektem. Ve druhé sekci souboru, nazvané "Files", jsou pak popisy všech souborů projektu. Popisy i všechny soubory (tj. kompletní projekt) jsou po zastavení programu uloženy do jednoho souboru s příponou fpr.

DLL modul může obsahovat značné množství relativně samostatných funkcí, které lze volat přímo, nebo z jiných DLL prostřednictvím zabudovaného mechanizmu volání přes funkce jádra FR4.S výhodou lze použít tzv. aliasy. V modulu, ve kterém potřebujeme volat nějakou "externí" funkci (může to být celý samostatný dialog např. pro definování nějakých konstant) použijeme náhradní název (alias) a k přiřazení konkrétní funkce použijeme konfigurační funkci pro správu DLL z modulu sysl.dll.

Např. pro převod obrazovky do souboru v DXF formátu použijeme alias "dxfout" ve všech voláních externí funkce s tímto účelem. Volání aliasu "dxfin" může být součástí obsluhy tlačítka v nově vytvořeném řídícím dialogu. Tento postup umožnuje použít právě dostupný modul, který požadovaný převod provádí. Např. modul dxf.dll obsahuje pro převod obrazovka - DXF funkci číslo 2 (pro opačnou konverzi funkci číslo 1). Pomocí dialogu modulu sysl.dll zapíšeme přirazení dxfout = dxf.dll:2 a pro dxfin = dxf.dll:1. Popsaným postupem si můžeme "vypůjčit" funkce od ostatních DLL. Všechny DLL však musí být zaregistrovány v FR4.ini souboru!

FR4.ini obsahuje mimo jiné popis aktuální konfigurace DLL modulů v programu FR4.
Plug-in modul je DLL modul vytvořený dle níže uvedených pravidel. Může obsahovat jednu nebo více funkcí (dialogů), které lze aktivovat kliknutím nad položkou v příslušném submenu nebo kliknutím nad příslušnou ikonou v tool-baru. V DLL modulech je nutno používat vlastní "resources" DLL modulu, modul musí být sestavován se soubory FR4ctrl.cpp a FR4ctrl.h, které obsahují kód řídící třídy F_dispatch. Za běhu programu využívá DLL modul služby "hlavniho" programu (FR4) a členských funkcí řídící třídy.

Konfigurační pravidla:

Sekvence příkazů musí být uvozena klíčem [MENU] .
Položky do lišty menu musí být uvozeny klíčovým slovem Main a znakem "=" a oddělovány znakem ",". Znak následující za znakem "&" je v menu podtržen a může sloužit k výběru položky v menu. Přidávané položky se uloží do hlavního menu za položku "File".
Položky jednotlivých submenu je třeba popsat tak, že každý řádek popisu začíná názvem submenu z popisu v menu a znakem "=", za kterým jsou položky popsány jménem DLL modulu (např. sysl.dll), oddělovacím znakem ":", číslem funkce v modulu, a pokud má být pro tuto funkci zařazena ikona do tool-baru, pak bezprostředně za číslem funkce musí být uveden znak "#". Oddělovací mezera se do tool-baru zařadí uvedením položky, která obsahuje jen znak "#".
Separátor se do submeny vloží polo6kou, která obsahuje pouze znak "*".

Příklad sekvence příkazů pro konfiguraci menu, submenu a tool-baru:

[MENU] 
Main=&User,&Test 
&User=#,test02.dll:1#,test01.dll:1#,sysl.dll:1# 
&Test=test01.dll:2,test02.dll:2#,*,test02.dll:3#,test02.dll:4# 

Relativní nezávislost DLL modulu zajišťují dvě interfejsové C-funkce. První z nich (Load_Resource) je využívána hlavním programem po startu, kdy je konfigurováno menu a tool-bar, druhá (Go_Function) je volána po výběru položky v submenu nebo kliknutí nad ikonou tool-baru a zajistí obvykle aktivaci požadovaného dialogu, který je součástí DLL modulu. Funkce je třeba deklarovat v definičním souboru "modul.def". Např. pro služební DLL (sysl.dll) je třeba vytvořit "sysl.def":

 
; sysl.def : Declares the module parameters for the DLL. 
 
LIBRARY      "SYSL" 
DESCRIPTION  'SYSL Windows Dynamic Link Library' 
 
EXPORTS 
    ; Explicit exports can go here 
	Go_Function @2 
	Load_Resource @3 

Interfejsová funkce pro konfigurační účely (Load_Resource) obsahuje řadu parametrů, které umožňují zařadit text položky do submenu pomocí funkce "AppendMenu", zařadit ikonu do tool-baru pomocí funkce "Register_button" a zaregistrovat text status-baru dialogu. Každý dialog zařazený do DLL modulu musí být označen číslem a každý dialog musí být opatřen výše uvedenou sekvencí kódu . Číslování začíná od čísla 1 a musí být nepřetržité (1,2,3,...). V dále uvedém přikladě obsahuje modul jen jeden dialog. Parametry specifické pro dialog jsou zvýrazněny:

extern "C" BOOL FAR PASCAL EXPORT Load_Resource(F_dispatch* Fdis, 
             CMenu* menu,UINT fce,UINT ID_f,CToolBar *tbar,BOOL ico) 
{ 
  TRY 
  { 
    // HINSTANCE for this "modul.dll" 
        HINSTANCE hin = Fdis->Get_dll_HINSTANCE("sysl.dll"); 
        HINSTANCE hAppInst = AfxGetResourceHandle(); 
        char buf[100];	 	 	  
 
        switch(fce) 
       { 
	case 1:	// function number 1 
		// load menu item text 
		   LoadString(hin, ID_FCE1 ,buf,100); 
		// append item to menu 
		   menu->AppendMenu(MF_STRING,ID_f,buf), 
		// add icon into tool-bar 
		   if(ico)Fdis->Register_button(hin,
                             ID_f, IDB_SYSDIAL ,tbar,buf); 
		// load text for status bar  
		   LoadString(hin, IDS_SYSDIAL ,buf,100); 
		// register menu item ID's 
		   Fdis->Add_IDs(ID_f, 1 ,hin,buf); 
	break; 
 
	// TODO: add another function menu item and ID's 
		 
	default: 
	 TRACE0("SYSL - ERROR Load_Resource - unknown function\n"); 
	break; 
        } 
   } 
    
   CATCH_ALL(e) 
   { 
	TRACE0("SYSL - ERROR Load_Resource\n"); 
	return FALSE; 
   } 
   END_CATCH_ALL 
   return TRUE; 
} 

Pozn ID_FCE1 a IDS_SYSDIAL jsou identifikátory textů a IDB_SYSDIAL je identifikátor bitmapy 24 krát 24 bodů (pro ikonu v tool-baru) v lokálních "resources" DLL modulu.

Pomocná funkce pro registraci ikony tool-baru:

  
BOOL Register_button(HINSTANCE hin,UINT ID_fce, 
                        UINT ID_BITMAP,CToolBar* tbar,char* tbtext) 

	výstup:	TRUE, pokud je ikona zaregistrována

	hin	parametr "HINSTANCE" DLL modulu
 
	ID_fce	identifikační číslo funkce DLL modulu 
                       (přidělené programem!)
 
	ID_BITMAP bitová mapa ikony uložená 
                       v "resources" DLL modulu
 
	tbar	ukazatel na tool-bar programu

	tbtext	ukazatel na identifikační text funkce
                        zobrazovaný u ikony
	 

Druhá interfejsová funkce slouží k aktivaci, tj. k vyvolání (zobrazení) dialogu. DLL modul může obsahovat několik navzájem nezávislých dialogů. K výběru dialogu slouží parametr "fce". Dále uvedený příklad obsahuje pouze jeden dialog, a proto parametr "fce" může nabýt pouze hodnotu 1. Řídící třída obsahuje údaje o všech DLL modulech a jejich funkcích. Pro každou funkci je k dispozici parametr "status" prostřednictvím funkce "Get_IDs_status". Bit 1 tohoto parametru je využíván k indikaci, zda dialog je (bit 1 =1) nebo není (bit 1 =0) aktivován. Výchozí stav zajišťuje "hlavní" program. Objekt dialogu je vytvořen konstruktorem s doplňujícím parametrem Fdis typu (F_dispatch*). Tím je umožněn přístup k řídící třídě všem členským funkcím třídy aktivovaného dialogu. Funkcí AfxSetResourceHandle je nastaven přístup k "resources" tak, aby byl dialog hledán v DLL modulu . V uvedeném příkladě je označen identifikátorem "IDD_SYSDIALOG". Hlavní program zajišťuje pozicování dialogu v okně běžící úlohy. K tomuto účelu slouží tzv. "registrování" dialogu pomocí funkce "Register_dialog". V příkladě je pozice dialogu ovlivňována existencí a hodnotou "globálního" parametru. Dialog může být umístěn vlevo nebo vpravo při okraji okna úlohy. Navíc je nastavením druhého parametru funkce "Register_dialog" na hodnotu identifikace funkce nastaven režim, při kterém ikona v tool-baru příslušná k funkci zůstane po kliknutí a aktivaci dialogu ve "stisknutém" stavu až do zrušní dialogu (na cancel) nebo druhého kliknutí nad ikonou. Proto druhý pokus o aktivování dialogu ikonou je směrován do sekce "else", kde je realizována úplná deaktivace a zrušení dialogu (i objektu). Provedeno je nalezení záznamu o dialogu ve strukturách řídící třídy, nulování bitu parametru "status", zrušení registrace dialogu, zrušení objektu funkcí DestroyWindow a výpis hlášení do status-baru.

Příklad implementace nemodálního dialogu:

 
extern "C" BOOL FAR PASCAL EXPORT Go_Function(F_dispatch* Fdis,UINT fce) 
{ 
  TRY 
  { 
    HINSTANCE hin = Fdis->Get_dll_HINSTANCE("sysl.dll"); 
    HINSTANCE hAppInst = AfxGetResourceHandle(); 
    char buf[100]; 
	  
    if(fce==1) 
    { 
      Fdis->Find_IDs_fce_number(1,hin); 
      UINT st = Fdis->Get_IDs_status(); 
      if((st&0x0002)==0) 
      {
        Sysd* cbl = new Sysd(CWnd::FromHandle(Fdis->Get_mfw_HWND()),Fdis); 
        AfxSetResourceHandle(hin); 
        // create dialog 
        if(cbl->Create(IDD_SYSDIALOG,Fdis->Get_frame_addr())==FALSE) 
	AfxMessageBox("ERROR Create SYSL Dialog"); 
        AfxSetResourceHandle(hAppInst); 
 
        // only one dialog can be active 
        Fdis->Put_IDs_status(st|0x2); // set bit:1 
 
        // window into parent window and must be declared as "transparent" 
        cbl->SetParent(Fdis->Get_frame_addr()); 
 
        // register dialog 
        LoadString(hin,ID_DPOSITION,buf,100); 
        UINT pos = DP_RIGHT; 
        if(Fdis->Find_param(&CString(buf))) 
        { 
          LoadString(hin,ID_LEFT,buf,100); 
          if(Fdis->Compare_param_value(&CString(buf)))pos=DP_LEFT;
        } 
        Fdis->Register_dialog((CWnd*)cbl,Fdis->Get_IDs_ID(),pos); 
        LoadString(hin,ID_SCONTROLD,buf,100); 
        Fdis->Status_text(buf); 
      } 
      else  
      { 
        // cancel registered dialog on click tool button 
        Fdis->Find_IDs_fce_number(1,hin); 
        UINT st = Fdis->Get_IDs_status(); 
        Fdis->Put_IDs_status(st&0xFFFD);	// reset bit:1 
        CWnd *wn = Fdis->Get_dialog_addr(Fdis->Get_IDs_ID()); 
        Fdis->Unregister_dialog(wn); 
        wn->DestroyWindow(); 
        // text into status-bar 
        LoadString(hin,ID_SCONTROLDCAN,buf,100);
        Fdis->Status_text(buf); 
      } 
    } 
 
   // TODO: add another dialog 
 
 } 
 CATCH_ALL(e) 
 { 
   TRACE0("SYSL - ERROR Go_Function\n"); 
   return FALSE; 
 } 
  END_CATCH_ALL 
  return TRUE; 
} 

    HINSTANCE hAppInst = AfxGetResourceHandle(); 
    char buf[100]; 
 
   if(fce==4) 
  { 
   Fdis->Find_IDs_fce_number(4,Fdis->Get_dll_HINSTANCE("test02.dll")); 
   UINT st = Fdis->Get_IDs_status(); 
   if((st&0x0002)==0) 
   {
     DIAL2* dial = new DIAL2(CWnd::FromHandle(Fdis->Get_mfw_HWND()),Fdis); 
     AfxSetResourceHandle(Fdis->Get_dll_HINSTANCE("test02.dll")); 
 
     // create dialog 
     if(dial->Create(IDD_DIALOG1,Fdis->Get_frame_addr())==FALSE) 
	AfxMessageBox("ERROR Create Dialog in DLL2"); 
     AfxSetResourceHandle(hAppInst); 
 
     // only one dialog can be active 
     Fdis->Put_IDs_status(st|0x2);	// set bit:1
 
     // register dialog 
     Fdis->Register_dialog((CWnd*)dial,0,DP_FREE); 
   } 
   else
   { 
     Fdis->Show_registered_dialogs(); 
     Fdis->Status_text("dialog is already active");
   }
 } 

void DIAL2::OnCancel()
{ 
  // TODO: Add extra cleanup here 
  Fdis->Status_text("DIAL2: OnCancel"); 
  Fdis->Find_IDs_fce_number(4,Fdis->Get_dll_HINSTANCE("test02.dll")); 
  UINT st = Fdis->Get_IDs_status(); 
  Fdis->Put_IDs_status(st&0xFFFD);  // reset bit:1 
  Fdis->Unregister_dialog(this); 
  DestroyWindow();
} 

 
  int i;	  
  Modalnidialog dlg(CWnd::FromHandle(Fdis->Get_mfw_HWND()),Fdis); 
  switch(fce) 
 { 
   case 1: 
	// register dialog - necessary if tool button in use 
	Fdis->Register_dialog(NULL, 0  ,DP_FREE); 
	i = dlg.DoModal(); 
	if(i==-1)AfxMessageBox("ERROR DoModal!"); 
	Fdis->Unregister_dialog(NULL); 
   break; 

Třída F_dispatch obsahuje skupinu funkcí, které řídí umisťování nemodálních dialogů na okrajích zobrazovacího okna úlohy. Okna "registrovaných" dialogů budou udržována na okrajích i po změně rozměrů okna, lze je najednou zrušit nebo dočasně zneviditelnit. Registrovaný dialog musí mít následující vlastnosti v "resources": Style = PopUp, Border = Dialog Frame, 3D-look a Transparent. Atribut "visible" nenastavovat, bude nastaven až po umístění dialogu funkcí "Register_dialog". Registrace nemodálního dialogu:

  
BOOL Register_dialog(CWnd* wn,UINT IDs,UINT pos) 
          výstup:    FALSE, pokud je dialog již registrován. 
          wn  ukazatel na objekt nemodálního dialogu. 
          IDs  identifikačni číslo přiřazené funkci v daném DLL.Pokud
                existuje v "tool baru" tlačitko pro právě registrovaný
                dialog, pak zůstává po aktivaci dialogu stlačeno až do
                zrušení registrace dialogu. Pokud má být možné dialog
                zrušit kliknutím nad stlačeným tlačítkem, pak je nutno
                provést úpravu dle přikladu 2. Je-li identifikační číslo
                rovno nule,  pak registrace nemá na ovládání tlačítka
                v "tool baru" vliv. Dialog se aktivuje "kliknutím" nad
                tlačítkem, které pak bude ve stlačené poloze jen krátký
                okamžik. 
	pos	pozice dialogu v okne úlohy: 
		DP_FREE	- dialog není vázán k okraji okna 
		DP_FIRST          - dialog bude zařazen na začátek
                               fronty umisťovaných dialogů 
		DP_LEFT           - bude umístěn k levému okraji
		DP_TOP            - bude umístěn pod horním okrajem 
		DP_RIGHT         - bude umístěn k pravému okraji 
		DP_BOTTOM     - bude umístěn nad spodním okrajem.
 
	Pozn. 	DP_FIRST lze kombinovat s umístěním k okraji. 
		DP_FREE je vhodné použít s nastavením dialogu
                                        v "resources": 
		Style = Popup, Border = Dialog Frame a nastavit:
                        Titlebar, System meny, 3D-look, Center. 
 
	Příklad 1 - vytvoření a registrace dialogu 
                            (jako funkce 1 MOJE.dll): 
 
	extern "C" BOOL FAR PASCAL EXPORT Go_Function(
                       F_dispatch* Fdis,UINT fce) 
	{ 
	TRY 
	{ 
	 HINSTANCE hAppInst = AfxGetResourceHandle(); 
	  
	 if(fce==1) 
	 { 
	   Fdis->Find_IDs_fce_number(1,
                     Fdis->Get_dll_HINSTANCE("MOJE.dll")); 
	   UINT	st = Fdis->Get_IDs_status(); 
	   // is created and active ? 
	   if((st&0x0002)==0) 
	   {		   
	    Muj_dialog cbl = new Muj_Dialog(
                         CWnd::FromHandle(Fdis>Get_mfw_HWND()),Fdis); 
	    AfxSetResourceHandle(Fdis->Get_dll_HINSTANCE("MOJE.dll")); 
 
	    // create dialog 
	    if(Muj_Dialog->Create(IDD_DIALOG,
                                        Fdis->Get_frame_addr())==FALSE) 
                          AfxMessageBox("ERROR Create Dialog"); 
	    AfxSetResourceHandle(hAppInst);
 
       	    // only one dialog can be active 
                Fdis->Put_IDs_status(st|0x2);	// set bit:1 
 
	    // window into parent window
                // and must be declared as "transparent" 
	    Muj_dialog->SetParent(Fdis->Get_frame_addr()); 		 
 
	    // register dialog 
	    Fdis->Register_dialog((CWnd*)Muj_dialog, 0,DP_LEFT ); 
 
	    // text on status bar 
	    Fdis->Status_text("Muj_dialog was created a registered!"); 
	  } 
	  else  
	  { 
                // all registered dialogs will be visibl 
	   Fdis->Show_registered_dialogs(); 
	   Fdis->Status_text("Muj_dialog is already active!");      	   
	  } 
	 } 
 
	atd... 
 
	Příklad 2 - zrušení dialogu po kliknutí nad stlačeným
                            tlačítkem v "Go_Function": 
 
	// is created and active ? 
	if((st&0x0002)==0) 
	{		   
	  . . . 
	} 
	else 
	{ 
	  // dialog is active - 
              //cancel registered dialog on click tool button 
	   Fdis->Find_IDs_fce_number(1,
                                    Fdis->Get_dll_HINSTANCE("MOJE.dll")); 
	   UINT	st = Fdis->Get_IDs_status(); 
	   Fdis->Put_IDs_status(st&0xFFFD);	// reset bit:1 
	   CWnd *wn = Fdis->Get_dialog_addr(Fdis->Get_IDs_ID()); 
	   Fdis->Unregister_dialog(wn); 
	   wn->DestroyWindow(); 
	   Fdis->Status_text("dialog was  cancelled"); 
	} 

  
BOOL Unregister_dialog(CWnd* wn) 
            Výstup: FALSE, pokud ukazatel na dialog nebyl nalezen. 
            wn  ukazatel na objekt nemodálního dialogu. 
 
	Příklad použití: 
 
	void Muj_dialog::OnCancel()  
	{ 
	// TODO: Add extra cleanup here 
	Fdis->Status_text("Muj_dialog - cancelled"); 
	Fdis->Find_IDs_fce_number(4,
                                Fdis->Get_dll_HINSTANCE("MOJE.dll")); 
	UINT	st = Fdis->Get_IDs_status(); 
	Fdis->Put_IDs_status(st&0xFFFD);	// reset bit:1 
	Fdis->Unregister_dialog(this); 
	DestroyWindow();	   
	} 
 
             Pozn.: 	Pro správné zrušení objektu nutno do třídy
                                  Muj_dialog zapsat funkci: 
 
	virtual void PostNcDestroy() {delete this;}; 

 
  
 BOOL Hide_registered_dialogs(void) 
	Výstup: FALSE, pokud není žádný dialog zaregistrován, 

 
  
 BOOL Show_registered_dialogs(void); 
	Výstup: FALSE, pokud není žádný dialog zaregistrován, 

 
  	UINT	st = Fdis->Get_IDs_status();	// status 
	Fdis->Put_IDs_status(st|0x2);		// set bit:1 

 
 
	Fdis->Put_IDs_status(st&0xFFFD);	// clear bit:1 
	Fdis->Unregister_dialog(this); 
	DestroyWindow();	   

 
  
 BOOL Cancel_all_dialogs(void); 
	Výstup:	FALSE, pokud není žádný dialog zaregistrován. 

   
BOOL Recalculate_registered_dialogs(BOOL repaint) 
	Výstup: 	vždy TRUE 
	repaint	parametr přenášený do funkce
                      "MoveWindow(,,,,repaint)", TRUE způsobí, že
                       dialogy budou překresleny v nových polohách.

 
 // nastavit interní ukazatel na identifikační 
 // číslo funkce 1 dll MOJE.dll 
 Fdis->Find_IDs_fce_number(1,
                        Fdis->Get_dll_HINSTANCE("MOJE.dll")); 
 // nulovat status bit 
 UINT st = Fdis->Get_IDs_status(); 
 Fdis->Put_IDs_status(st&0xFFFD);  // reset bit:1 
 // získat ukazatel na objekt (CWnd dialogu) dle
 // nastaveného identifikačního čísla 
 CWnd *wn = Fdis->Get_dialog_addr(Fdis->Get_IDs_ID()); 
 // zrušit registraci dialogu a zrušit okno 
 // dialogu vyhledaného objektu 
 Fdis->Unregister_dialog(wn); 
 wn->DestroyWindow(); 
 
  
CWnd* Get_dialog_addr(UINT IDs) 
	výstup:	ukazatel na CWnd dialogu 
	IDs	identifikační číslo funkce v daném DLL modulu 

 
  
BOOL Get_base_view(RECT* rec) 
            Výstup:  vždy TRUE. 
            rec       souřadnice okna úlohy 
                        (levý horní a pravý dolní krajní bod) 

 
  
BOOL Get_view(RECT* rec) 
	Výstup: 	vždy TRUE. 
	rec	souřadnice zbývajícího okna 
                        (levý horní a pravý dolní krajní bod) 

 
  
BOOL Add_dll(const char* name) 
	výstup	TRUE, pokud je DLL zaregistrovano 
	name	nazev souboru s DLL modulem (např. modul.dll) 

 
  
BOOL First_dll() 
	výstup	TRUE, pokud záznam existuje 

 
  
BOOL Next_dll() 
	výstup	TRUE, pokud byl přesun uskutečněn,
                  FALSE, pokud byl záznam poslední v řetězci. 

 
  
BOOL Find_dll(const char* name) 
	výstup	TRUE, pokud byl záznam nalezen 
	name	název hledaného DLL 

 
  
BOOL Find_dll_HINSTANCE(HINSTANCE hinstin) 
	výstup	TRUE, pokud byl záznam nalezen 
	hinstance     hledaný parametr typu HINSTANCE. 

 
  
UINT Get_dll_status(void) 
	výstup	hodnota statusu. Interní ukazatel musí
                         být nastaven na úpožadovaný záznam! 

 
  
BOOL Put_dll_status(UINT status) 
	výstup	TRUE, pokud byl zápis proveden 
	status	hodnota parametru "status" 

 
  
void* Get_dll_pointer(void) 
	výstup	obsah parametru "pointer" typu void* 

  
BOOL Put_dll_pointer(void* pointer) 
	výstup	TRUE, pokud byl zápis proveden 
	pointer	hodnota parametru pointer 

  
HINSTANCE Get_dll_HINSTANCE(void) 
	výstup	hodnota parametru HINSTANCE DLL
                       modulu, na jehož záznam v řetězci je
                       nastavem interní ukazatel. 

 
  
HINSTANCE Get_dll_HINSTANCE(const char* name) 
	výstup	hodnota parametru HINSTANCE DLL
                        modulu zadaného jména. Pokud není DLL
                        modul nalezen, pak výstupní hodnota = 0. 

  
LPSTR Get_dll_name(void) 
	výstup	ukazatel	na řetězec se jménem DLL modulu 

  
BOOL Add_IDs(UINT ID,UINT fce,HINSTANCE hinstin,char* status_text) 
	výstup	TRUE, pokud byl zýznam přidán. 
	ID	identifikační číslo v submenu (přiděluje 
                       "hlavni" program při konfigurování). 
	fce	číslo funkce v DLL modulu 
	hinstin	HINSTANCE přislušející DLL modulu 
	status_text	text pro status-bar. Text se
                       objeví ve status-baru, pokud je kurzor nad
                       položkou v submenu. Zaváděn je ve funkci
                       "Load_Resource". 

 
  
BOOL Find_IDs(UINT ID) 
Funkce nastavuje interní ukazatel na záznam s hledaným atributem. 
	výstup	TRUE, pokud byl záznam nalezen 
	ID	hledané identifikační číslo.  

 
  
BOOL Find_IDs_fce_number(UINT fce,HINSTANCE hinstin) 
Funkce nastavuje interní ukazatel na záznam se zadanými parametry. 
	výstup	TRUE, pokud byl záznam nalezen. 
	fce	číslo funkce v DLL modulu 
	hinstin	HINSTANCE DLL modulu, 
                       ke kterému číslo funkce přísluší.

 
  
UINT Get_IDs_ID(void) 
	výstup	hodnota identifikačního čísla ze záznamu,
                        na který je nastaven interní ukazatel. 
                        Pokud žádný záznam není, pak =0. 

 
  
UINT Get_IDs_fce_number(void) 
	výstup	číslo funkce ze záznamu, na který
                       je nastaven interní ukazatel. Pokud
                       žádný záznam není, pak výstup = 0. 

 
  
HINSTANCE Get_IDs_HINSTANCE(void) 
	výstup	hodnota parametru HINSTANCE ze záznamu,
                       na který je nastaven interní ukazatel. 
                       Pokud žádný záznam není, pak výstup = 0. 

 
  
UINT Get_IDs_status(void) 
           výstup hodnota parametru status ze záznamu,
                           na který je nastaven interní ukazatel. 

 
  
BOOL Put_IDs_status(UINT status) 
            výstup TRUE, pokud lze status zapsat. 
	status	hodnota parametru status,
                       která má být zapsána do záznamu. 

  
LPSTR Get_IDs_status_text(void) 
             výstup ukazatel na textový řetězec pro status-bar.
             Pokud záznam chybí, pak výstup = NULL. 

Pro předávání informací mezi jednotlivýmí DLL moduly jsou určeny globální a projektové parametry. Zpřístupněny jsou prostřednictvím řídící třídy F_dispatch, která je dědicem třídy F_param. Tato třída obsahuje funkce pro obsluhu řetězce zmíněných parametrů. Každý parametr je definován dvěma textovými řetězci (jménem a hodnotou) a jedním stavovým parametrem. Rozdíl mezi globálními a projektovými parametry je pouze v nastavení bitů stavového parametru. Pomocí modulu sysl.dll lze parametry číst i měnit! Oba typy parametrů jsou ve stejném řetězci, a lze je pomocí dále popsaných funkcí programově vytvářet a rušit a také modifikovat jejich hodnoty. Třída F_param obsahuje interní ukazatel do řetězce, který je využíván některými funkcemi.

Přidat parametr:

  
BOOL Add_param(CString *name,CString *value) 
	výstup	TRUE, pokud je parametr uložen, jinak FALSE. 
	name	název parametru 
	value	hodnota parametru 

Nastavit interní ukazatel na první parametr v řetězci:

  
BOOL First_param() 
	výstup	TRUE, pokud byl příkaz splněm, jinak FALSE,
                        pokud žádný parametr v řetězci není. 

Přestavit interní ukazatel na další parametr v řetězci:

  
BOOL Next_param() 
	výstup	TRUE, pokud byl příkaz splněn, jinak FALSE, pokud je
              řetězec prázdný, nebo další parametr není. V tomto případě
              má interni ukazatel hodnotu NULL! 

Nalézt parametr zadaného jména:

  
BOOL Find_param(CString *name) 
	výstup	TRUE. pokud byl parametr nalezen, jinak FALSE. 
	name	název hledaného parametru. 

Zrušit parametr zadaného jména:

  
BOOL Delete_param(CString *name) 
	výstup	TRUE, pokud byl parametr zrušen, jinak FALSE 
                        (parametr nebyl např. nalezen, nebo je uzamknut). 
	name	nízev parametru, který má být zrušen.	 

Překopírovat (přečíst) jméno parametru, na který je nastaven interní ukazatel:

  
BOOL Get_param_name(CString *name) 
	výstup	TRUE, pokud lze název parametru přečíst, jinak FALSE. 
	name	přečtené jméno parametru. 

Změnit hodnotu parametru:

  
BOOL Set_param_value(CString *value) 
	výstup	TRUE, pokud byla hodnota parametru změněna, 
                         jinak FALSE (je např. "read-only"). 
	value	nová hodnota parametru. 

Překopírovat (přečíst) hodnotu parametru:

  
BOOL Get_param_value(CString *value) 
	výstup	TRUE, pokud bylo možné hodnotu přečíst, jinak FALSE.

Porovnat zadanou hodnotu s hodnotou parametru, na který je nastaven interni ukazatel:

  
BOOL Compare_param_value(CString *value) 
	výstup	TRUE, pokud jsou hodnoty shodné, jinak FALSE. 
	value	zadaná hodnota k porovnání 

Uzamknutí parametru:

  
BOOL Lock_param_name(CString *name) 
	výstup	TRUE, pokud je ve stavovem slove parametru nastaven
               příslušný bit, jinak pokud není parametr nalezen FALSE. 
	name	název parametru 

Odemknutí parametru:

  
BOOL Unlock_param_name(CString *name) 
	výstup	TRUE, pokud byl parametr nalezen a příslušný bit
                        nulován, jinak FALSE. 
	name	nízev parametru 

Uzamknutí hodnoty parametru:

  
BOOL Lock_param_value(CString *name) 
	výstup	TRUE,pokud byl parametr nalezen a příslušný bit nastaven,
                         jinak FALSE. 
	name	název parametru 

Odemknutí hodnoty parametru:

  
BOOL Unlock_param_value(CString *name) 
	výstup	TRUE, pokud byl parametr nalezen a příslušný bit nulován, 
                         jinak FALSE. 
	name	nízev parametru 

Dotaz na uzamknutí parametru nebo jeho hodnoty:

  
BOOL	Is_param_locked() 
	výstup	TRUE, pokud je parametr, na který je nastaven interní
                         ukazatel, uzamknut. Jinak FALSE. 

Dotaz na uzamknutí parametru:

  
BOOL Is_param_name_locked() 
	výstup	TRUE, pokud je parametr, na který je nastaven interní
                         ukazatel, uzamknut. Jinak FALSE. 

Dotaz na uzamknutí hodnoty parametru:

  
BOOL Is_param_value_locked() 
	výstup	TRUE, pokud je hodnota parametru, na který je nastaven
                        interní ukazatel, uzamknut. Jinak FALSE. 

Zrušení všech parametrů v řetězci:

  
void Delete_all_params(void) 
	Parametry jsou zrušeny bez ohledu na to, zda jsou
	nějakým způsobem uzamčeny! 

Další funkce třídy F_params jsou uvedeny v FR4ctrl.h . Pozn. Jedna instance této třídy je součástí jádra FR4. Lze ji využít pro ukládání tzv. globálních a projektových parametrů.

//     Uložení hodnoty projektového parametru "muj patametr" 
//     (Fdis je ukazatel na řídící třídu jádra F_dispatch):

Fdis->Add_param("Project/muj parametr","uloha");

//     Přečtení téhož parametru a sestavení jména souboru:

String path = (*Fdis)["Project/muj parametr"] + ".xyz";

//    "path" bude obsahovat řetězec: uloha.xyz


//     S výhodou lze použít konverzní funkce k uložení 
//     parametru např. typu "long" (o hodnotě 103)
//     do projektového parametru "poradi":

long poradi = 103;
Fdis->Set_param_long("Project/poradi",poradi);

//      přečíst hodnotu parametru "poradi" a uložit 
//      do parametru "stav" např v jiném DLL modulu:

long stav = Fdis->Get_param_long("Project/poradi");

//     parametr "stav" má nyní hodnotu 103.

		bit:                0                          1 
FA_CANOPEN	0x0000              -                          - 
FA_RONLY	0x0001  soubor pro zápis i čtení  soubor jen pro čtení dat 
FA_TEXT		0x0002  binární soubor            textový soubor 
FA_HEADER	0x0004  soubor bez hlavičky       soubor s hlavičkou 
FA_FR4		0x0008  starý typ (FEM)           nový typ (FR4) 
FA_DYNMEM	0x0010  jen soubor                po otevření vytvoř 
                                                       dyn. pole 
FA_ONLYDYN	0x0020  soubor i dyn. pole        jen dyn. pole 
FA_FILESTAT	0x0040              -             (char) status je v 
                                                       souboru 
FA_FILEATTR	0x0080              -             (long) atribut 
                                                       je v souboru  
FA_CHAIN	0x0100  dyn. pole tabulek         řetězec záznamů  
FA_VARLEN	0x0200  zázn.pevné délky          záznamy proměnné délky  
FA_INDEX	0x0400              -             indexový soubor 
FA_DATINDEX	0x0800              -             udržovat index dle klíče 

Příklady typů souborů:

- soubor, který bude pouze zdrojem informací (tj. bude chráněn
   oproti zápisu),  informace jsou uloženy binárně. Vhodný 
   atribut =  FA_RONLY. 
- soubor je textový a bude po otevření editován.  
   Vhodné atributy = FA_TEXT | FA_DYNMEM . Atributy zajistí,
   že se po otevření položky vytvoří řetězec záznamů jako
   dynamická struktura v paměti. 
- dynamické pole s binárními daty.  
   Vhodné atributy = FA_ONLYDYN. Po otevření položky se
   vytvoří dynamické pole v paměti. Po uzavření položky bude
   pole zrušeno. Je-li přidán atribut FA_CHAIN, pak je dynamické
   pole vytvořeno v podobě řetězce záznamů a záznamy nemusí
   mít konstantní délku. Varianta záznamů s nekonstantní délkou
   je podporována mechanizmem pro "nové" soubory (FA_FR4). 

Pozn.
Atributem FA_FR4 lze označit jen soubory, které mají speciální uspořádání. Každý soubor má hlavičku, ve které jsou uloženy parametry souboru a offset na začátek dat. Soubory tzv. starého typu jsou různorodé a jejich parametry jsou součástí jednotlivých položek souboru projektu.

Atributy FA_FILESTAT a FA_FILEATTR naznačují, že pomocné parametry záznamu jsou ukládány do souboru. Tyto dva parametry obsahuje každý záznam dynamického pole.

Atribut FA_HEADER naznačuje, že data nejsou v souboru uložena s nulovým offsetem. Podrobnosti musí být popsány v parametrech položky!

Po otevření souboru je nastaven "status" položky. Možné jsou následující stavy:

		bit	    0                1 
FS_DYNMEM	0x0001	    -        vytvořena dynam.
                                     struktura v paměti 
FS_DYNCHAIN	0x0002	dynamická    dynamický řetězec
                        tabulka      záznamů 
                        záznamů
FS_OPENED	0x0004      -        soubor byl otevřen 
FS_MEMSAV	0x0008      -        uložit dynam. strukturu
                                     do souboru před
                                     uzavřením souboru 

Přidat položku do projektu:

Nové položky se do otevřeného projektu zařazují pomocí funkce "Add_dyn_table". Tato funkce předává mimo jiné i tributy položky projektu. Ke zpřístupnění souboru (dyn. pole) je nutno použít ještě funkci "Open_File". Její činnost je modifikována atributy. Po otevření souboru (dyn. pole) lze měnit pouze atribut "FA_RONLY" voláním funkce "Set_RONLY" a "Set_RW".

  
BOOL Add_dyn_table(CString *name,CString *type, 
		CString *subtype, CString *group, int attrib) 
	výstup	TRUE, pokud je položka přidána do projektu 
	name	název položky (souboru) 
	type	typ položky (souboru):       binary, text 
	subtype	podrobnější označení typu pro typ text např.
		dxf,html,plain,  
		pro binary např. xyz (souřadnice bodu) 
	group	vyjádření příslušnosti ke skupině dat např.
                        vstupy,výstupy 
	attrib	výše popsané atributy položky (souboru) projektu. 

Nastavit vnitřní ukazatel na první položku:

ž
BOOL First_dyn_table() 
	výstup	TRUE, pokud bylo nastavení úspěšné 

Pozn. Pozici vnitřního ukazatele vyu6ívají "Get" a "Is" funkce.

Nastavit vnitřní ukazatel na další položku v řetězci:

BOOL Next_dyn_table() 
	výstup	TRUE, pokud bylo nastavení úspěšné 

Nastavit vnitřní ukazatel na položku (soubor) zadaného názvu:

BOOL Find_dyn_table(CString *name) 
	výstup	TRUE, pokud byla položka nalezena 
	name	název položky (souboru), která má být nalezena 

Nastavit vnitřní ukazatel na položku (soubor) se zadaným číslem:

BOOL Find_dyn_table(UINT file_num) 
	výstup	TRUE, pokud byla položka nalezena 
	file_num	číslo položky 

Zrušit položku (soubor) zadaného jména:

BOOL Delete_dyn_table(CString *name) 
	výstup	TRUE, pokud byla položka nalezena a zrušena 
	name	název položky, která má být zrušena 
                        (včetně souboru na disku!) 

Ověřit, zda je vnitřní ukazatel nastaven na položku se zadaným jménem:

BOOL Is_dyn_name(CString *name) 
	výstup	TRUE, pokud jméno souhlasí 
	name	ověřovaný název položky (souboru) 

Ověřit, zda je vnitřní ukazatel nastaven na položku zadaného typu:

BOOL Is_dyn_type(CString *type) 
	výstup	TRUE, pokud typ souhlasí 
	type	ověřovaný typ položky (souboru) 

Ověřit, zda je vnitřní ukazatel nastaven na položku zadaného subtypu:

BOOL Is_dyn_subtype(CString *subtype) 
	výstup	TRUE, pokud subtyp souhlasí 
	subtype	ověřovaný subtyp položky (souboru) 

Ověřit, zda je vnitřní ukazatel nastaven na položku zadané skupiny:

BOOL Is_dyn_group(CString *group) 
	výstup	TRUE, pokud skupina souhlasí 
	group	ověřovaná skupina položky (souboru) 

Přečíst název položky (souboru), na kterou je nastaven vnitřní ukazatel:

BOOL Get_dyn_table_name(CString *name) 
	výstup	TRUE, pokud byl název přečten 
	name	přečtený název položky (souboru) 

Přečíst typ položky (souboru), na kterou je nastaven vnitřní ukazatel:

BOOL Get_dyn_table_type(CString *type) 
	výstup	TRUE, pokud byl typ přečten 
	type	přečtený typ položky (souboru) 

Přečíst subtyp položky (souboru), na kterou je nastaven vnitřní ukazatel:

BOOL Get_dyn_table_subtype(CString *subtype) 
	výstup	TRUE, pokud byl subtyp přečten 
	subtype	přečtený subtyp položky (souboru) 

Přečíst skupinu položky (souboru), na kterou je nastaven vnitřní ukazatel:

BOOL Get_dyn_table_group(CString *group) 
	výstup	TRUE, pokud byla skupina přečtena 
	group	přečtený subtyp položky (souboru) 

Přečíst atributy položky (souboru), na kterou je nastaven vnitřní ukazatel:

int Get_dyn_table_attrib() 
	výstup	atribut položky (souboru) 

Přečíst skupinu položky (souboru), na kterou je nastaven vnitřní ukazatel:

unsigned char Get_dyn_table_status() 
	výstup	aktuální status položky (souboru) 

Přečíst ukazatel na třídu popisující položku (soubor), na kterou je nastaven vnitřní ukazatel:

F_dyn* Get_dyn_table_pointer() 
	výstup	ukazatel na třídu popisující položku (soubor) 

Nastavení hodnot filtru pro vyhledávaní položek: Filtrace se uplatňuje při použití funkcí "First_dyn_table" a "Next_dyn_table".

BOOL Set_dyn_filter(CString *type,CString *subtype,CString *group) 
	výstup	TRUE, pokud bylo nastavení úspěšné 
	type	typ položky 
	subtype	subtyp položky 
	group	skupina položek 

Pozn. Pokud je některá položka NULL, pak není do "filtrace" zahrnuta.

Vypnout filtr:

BOOL Dyn_filter_off() 
	výstup	TRUE, pokud bylo nastavení úspěšné  

Zapnout filtr:

BOOL Dyn_filter_on() 
	výstup	TRUE, pokud bylo nastavení úspěšné  

Dynamická pole

Dynamická pole lze použít samostatně i ve spojení se soubory s níže popsanou strukturou. K dispozici jsou dva typy "dynamických polí":

- řetězec záznamů proměnné délky. Struktura je 
  vhodná pro práci se záznamy proměnné délky,
  které je třeba snadno editovat (především rušit
  a přidávat). 

- řetězec tabulek se záznamy konstantní délky.
  Struktura je vhodná pro práci s obsahy záznamů, 
  kdy je měněn nebo často jen čten jejich obsah. 

Pozn. Každý záznam v obou typech struktur je opatřen dvěma parametry. První je nazýván "status" a slouží k označování záznamů pro možnost práce jen s "označenou" částí záznamů, druhý umožňuje přiřadit záznamu číselnou hodnotu v rozsahu čtyř bajtů (typu long), tzv. atribut.

Typy souborů

Projekt může obsahovat čtyři typy souborů:

• textový soubor sestávající ze záznamů různé délky, které jsou ukončeny znaky . Soubor může obsahovat několik úvodních záznamů, které se od ostatních (datových) liší, tzv. hlavičku souboru.
  Pozn. Záznamy hlavičky jsou převedeny po "OPEN" do řetězce parametů položky projektu. Počet záznamů hlavičky musí být popsán před otevřením položky v parametrech položky jako parametr "offset" s hodnotou, která se rovná počtu záznamů hlavičky.

• binární soubor se záznamy pevné délky. Délka záznamu v bajtech musí být uvedena s parametrem položky "record_len". Soubor může být opatřen hlavičkou. Hodnota parametru položky "offset" musí být rovna offsetu na začátek dat v souboru. Další povinný parametr je parametr "table_len", který udává počet položek v tabulce řetězce tabulek (dynamického pole).

• soubor typu FR4 s pevnou délkou záznamů. Soubor obsahuje vždy hlavičku, za kterou jsou uložena data. Všechny údaje popisující soubor i členění dat jsou uloženy v hlavičce souboru.

Hlavička obsahuje:

- textový popis souboru (identifikace). Text má konstantní délku 68 znaků a je ukončen znaky

- tři identifikační bajty:

    1. bajt:	'F' označuje soubor se záznamy pevné délky 
		'V' označuje soubor se záznamy proměnné délky 
    2. bajt:	'1' v záznamu je obsažen bajt pro "status" 
		'0' v záznamu není bajt pro "status" 
    3. bajt:	'1' v záznamu je obsažen long pro "atribut" 
		'0' v záznamu není obsažen long pro "atribut" 
    4. bajt:	'1' k souboru vytvořit po otevření index 
                         začátků záznamů 
		'0' žádný index začátků záznamů 
    5. bajt:	'1' k souboru vytvořit po otevření indexový
                         soubor dle klíče 
		'0' žádný index dle klíče 

Pozn. Pro tento typ souboru je první identifikační bajt nastaven na 'F' a bajt 4. je nevýznamný.

- offset na začátek dat v souboru (čtyři bajty, parametr typu "long")

- záznamy v hlavičce souboru. Každý záznam začíná klíčovým slovem (názvem parametru), které neobsahuje znak "SP"(mezera je nahrazena znakem "_"). Za ním je jednou mezerou oddělen řetězec "hodnoty" ukončený bajtem s hodnotou 0. Pole parametrů je ukončeno prázdným záznamem ukončeným bajtem s hodnotou 0. Mezi koncem seznamu parametrů a začátkem dat může být nevyužitý prostor (rezerva).

Pozn. Povinné jsou parametry "record_len" a "table_len" pro soubory s pevnou délkou záznamů.

 - záznamy pevné délky. Pokud jsou příslušné
    i dentifikační bajty nastaveny,
    pak záznam obsahuje: 
    status	- jeden bajt (unsigned char),
                                pokud je definován 
    parametr	- čtyři bajty (long), pokud je
                                definován 
    data	- délka je zaznamenána
                                v parametru "record_len". 

• soubor typu FR4 s proměnnou délkou záznamů.

   Struktura souboru je obdobná.
   První identifikační bajt má hodnotu 'V' . Všechny
   identifikační bajty jsou významné.
   Rozdílná je struktura záznamu. Záznam obsahuje položky: 
   alokace	- čtyři bajty (long) = délka rezervovaného prostoru
		   pro data v bajtech 
   délka	- čtyři bajty (long) = skutečná délka dat v záznamu 
   status	- jeden bajt (unsigned char), pokud je definován 
   parametr	- čtyři bajty (long), pokud je definován 
   data		- libovolné bajty v rozsahu daném položkou "délka". 

 
pro práci se soubory a dynamickými strukturami v paměti: 
( je implementováno?  A = ano, N = ne.) 
-----------------------------------------------------------------
		   řetězec  řetězec  textový  binární  FR4    FR4	 
funkce	 	   zázn.    tabulek  soubor   soubor  "fix"  "var" 
-----------------------------------------------------------------
Open_File		A	A	A	A	A	A 
Close_File		A	A	A	A	A	A 
Is_Opened		A	A	A	A	A	A 
Set_RONLY		A	A	A	A	A	A 
Set_RW			A	A	A	A	A	A 
Add_Rec			A	A	A	A	A	A 
First_Rec		A	A	A	A	A	A 
Next_Rec		A	A	A	A	A	A 
Read_Rec		A	A	A	A	A	A 
Write_Rec		A	A	A	A	A	A 
Insert_Rec		A	A	N	A	N	N 
Mark_Rec		A	A	N	N	A	A 
Is_Rec_Marked		A	A	N	N	A	A 
Delete_Recs		A	A	N	N	N	N 
Undo_Rec		A	A	N	N	A	A 
Undo_Recs		A	A	N	N	A	A 
Find_Rec		A	A	A	A	A	A 
Get_Rec_Numbe		A	A	A	A	A	A 
Select_Rec		A	A	N	N	A	A 
Deselect_Rec		A	A	N	N	A	A 
Is_Rec_Selected		A	A	N	N	A	A 
Set_Parameter		A	A	N	N	A	A 
Get_Parameter		A	A	N	N	A	A 
Get_Rec_Length		A	A	A	A	A	A 
Clear_Rec		A	A	N	A	A	A 

Položky (soubory nebo dynamická pole) projektu
Dále popsané funkce jsou členskými funkcemi třídy F_dyn. Předpokládá se, že po výběru položky projektu je vnitřní ukazatel nastaven na vybranou položku projektu a funkcí "Get_dyn_table_pointer" lze získat ukazatel na třídu F_dyn. Tento ukazatel je pro každou položku (soubor) jedinečný a členské funkce třídy F_dyn umožňují pracovat s jednotlivými záznamy. Výsledky operací nad záznamy jsou indikovány stavem operace (návratovou hodnotou typu UINT):

 
popis		            význam kódu
-------------------------------------------------------- 
STAT_OK		0	úspěšné provedení 
STAT_NOOPENED	1	položka není "otevřena" 
STAT_OPENED	2	položka je již "otevřena" 
STAT_EOF	3	konec souboru nebo dat v paměti 
STAT_NOALLOC	4	nelze alokovat pam컝 
STAT_READONLY	5	položka je typu "read only" 
STAT_ERRATTR	6	chybná kombinace atributů 
STAT_LONGHEAD	7	příliš dlouhá hlavička 
STAT_ERRSIZE	8	není definována délka tabulky 
                           (parametr "table len") 
STAT_ERRLEN	9	není definována délka záznamu 
                           (parametr "record len") 
STAT_CANTCREA	10	soubor nelze založit 
STAT_ERRTYPE	11	atribut "FA_VARLEN" 
                           nemůže být akceptován 
STAT_ERRFSTAT	12 	atribut "FA_FILESTAT"
                           nemůže být akceptován 
STAT_ERRFATTR	13	atribut "FA_FILEATTR"
                           nemůže být akceptován 
STAT_NOTIMPL	14	není implementováno - 
                           volání funkce bez efektu 
STAT_LONGDATA	15	přílič dlouhá data 
STAT_NOTFOUND	16	záznam nebyl nalezen 
STAT_DATAOUT	17	požadavek na data mimo 
                           možný rozsah 
STAT_ISINDEX	18	soubor nelze otevřít, 
                           je to indexový soubor 

Každý záznam souboru, který byl převeden do struktury (tabulky nebo řetězce) v paměti, je opatřen dvěma dodatečnými položkami tzv. statusem a parametrem. Status je typu unsigned char. Bit 0 je vyhrazen pro označení záznamu k vymazání (funkcí Mark_Rec), bit 1 pro tzv. selekci (funkcí Select_Rec). Ostatní bity mohou být použity k podobným účelům. Při používání funkcí, které pracují se "statusem", je třeba mít na paměti, že každá položka projektu nemusí být "statusem" vybavena a příslušné funkce budou v tomto případě neúčinné!

Přehled typů souborů:

dle FA_FR4:	
soubory běžného typu			 
----------------------------------- 
- binární	- bez hlavičky		 
		- s hlavičkou 
- textové	- bez hlavičky 
		- s hlavičkou 
 
soubory typu FR4 
------------------------------------ 
- s pevnou délkou záznamu 
- s proměnnou délkou záznamů 	- bez indexového souboru 
				- s indexovým souborem 

Přehled přístupu k datům po otevření "položky projektu" a atributy, které jsou akceptovány:

práce v dynamických strukturách v paměti

FA_DYNMEM | FA_TEXT - řetězec záznamů v paměti. 
Místo FA_TEXT lze použít i FA_CHAIN. 
FA_DYNMEM - tabulky záznamů pevné délky v paměti 
Pokud mají být vytvořeny struktury jen v paměti, pak je
třeba uvést atribut FA_ONLYDYN. 

Jen soubor na disku

FA_TEXT - jen soubor typu běžný text (záznamy
končící ) 
FA_CANOPEN - jen soubor typu binární data.
Atribut FA_CANOPEN má hodnotu nula
a nemusí být používán!

Pozn. Pro oba typy přístupu k datům jsou parametry
FA_CHAIN, FA_VARLEN, FA_INDEX a FA_DATINDEX
bezvýznamné! 

 
FA_FR4 - soubor typu FR4 se záznamy pevné délky.
    
FA_FR4 | FA_VARLEN - soubor typu FR4 se zázmamy
proměnné délky (případně s indexovým souborem pro
přístup k jednotlivým záznamům - atribut FA_INDEX, 
nebo atribut FA_DATINDEX pro indexový soubor
organizovaný dle klíče). 

Kombinace - soubor převeden z disku do paměti

přidáním atributu FA_DYNMEM dojde k vytvoření struktury
v paměti vždy po otevření položky. 
Pro soubor typu FR4 se záznamy pevné délky může být
vhodné použít atribut FA_CHAIN v těch případech, kdy 
sou jednotlivé záznamy rušeny a vkládány! 

Úvodní část souboru může obsahovat speciální údaje
přidáním atributu FA_HEADER bude za začátek dat považována pozice u binárních dat daná parametrem "offset". Hodnota určuje posun v bajtech. U textových souborů bude parametr "offset" obsahovat počet vět, které tvoří hlavičku. Ty budou převedeny do parametrů "header_A", "header_B", atd. Poslední (26.) parametr bude mít název "header_Z". Hlavička textového souboru je tak omezena na 26 řádků. U souborů typu FA_FR4 je hlavička součástí souboru a atribut FA_HEADER nemá žádný význam!

 
Soubor a tedy i data převedená do paměti mohou být určena jen ke čtení 
přidáním parametru FA_RONLY. Každý pokus o zápis bude odmítnut! 
 
Rezervované názvy parametrů: 
offset		- pro textový soubor počet vět hlavičky,
                           u binárních offset v bajtech začátku dat. 
header_A až header_Z - 26 názvů jednotlivých řádků "textové" hlavičky. 
record_len	- délka dat v záznamu 
table_len	- počet záznamů v tabulce  
 
 
Příklad otevření a práce s položkou projektu typu textový soubor: 

//  Fdis je ukazatel na třídu F_dispatch, získaný jako parametr
//  DLL modulu (viz Go_Function). 
//  ukazatel na třídu typu soubor-dynamická pamě: 
F_dyn* mojedata; 
//  přidat položku do projektu: 
Fdis->Add_dyn_table(CString ("test.dat"),CString ("text"), 
                  CString ("plain"), CString ("testy"), FA_TEXT | FA_RW); 
//  otevřít soubor: 
mojedata=Fdis->Get_dyn_table_pointer(); 
//  zjistit ukazatel na soubor-dynamickou pamě 
mojedata->Open_File(Fdis->Get_dyn_table_attrib()); 
//  zapsat nová data: 
mojedata->Add_Rec('prvni radek',11L); 
mojedata->Add_Rec('druhy radek',11L); 
mojedata->Add_Rec('treti radek',11L); 
//  zavřít soubor: 
mojedata->Close_File(); 
 

//  další použití - otevřít a číst text 
char buf[200]; 
long len; 
Fdis->Find_dyn_table(CString("test.dat")); 
//  otevřít soubor: 
mojedata=Fdis->Get_dyn_table_pointer(); 
//  zjistit ukazatel na soubor-dynamickou pamě: 
mojedata->Open_File(Fdis->Get_dyn_table_attrib()); 
//  číst data: 
mojedata->Read_Rec((void*)buf,200,len); 
//  přechod na další záznam: 
mojedata->Next_Rec(); 
mojedata->Read_Rec((void*)buf,200,len); 
mojedata->Next_Rec(); 
mojedata->Read_Rec((void*)buf,200,len); 
//  zavřít soubor 
mojedata->Close_File(); 

Zapnout filtr: 
Filtrace se týká bitů 1 až 7 statusu a má vliv na funkce "First_Rec"
a "Next_Rec". Nastavením filtru funkcí "Set_filter" např. na hodnotu 0x02
a po zapnutí filtru funkcí "Filter_on"  lze vyhledat záznamy, které byly
označeny funkcí " Select_Rec". 
  
void Filter_On(void) 

 
Vypnout filtr: 
  
void Filter_Off(void) 

 
Nastavit filtr: 
  
BOOL Set_Filter(char st) 
	výstup	TRUE, pokud bylo nastavení úspěšné 
	st	"status" uložený ve filtru. Nastavení bitu 0 je
                        neúčinné (bit je použit k jiným čelům) 

 
Přečíst nastavení filtru: 
  
char Get_Filter(void) 
	výstup	"status" uložený ve filtru. 

 
Zrušit nastavení všech bitů statusu filtru: 
  
void Clear_Filter(void) 

 
Otevřít soubor nebo dynamické pole 
  
UINT Open_File(atrib) 
	výstup	kód operace 
	atrib	podmínky pro otevření souboru. Viz atributy
                        FA_xxxxx. 

 
Zavřít soubor nebo dynamické pole 
  
UINT Close_File(void) 
	výstup	kód operace 

 
Ověřit, zda je soubor nebo dynamická struktura připravena
k použití (soubor otevřen): 
  
BOOL Is_Opened(void) 
	výstup	TRUE, pokud je soubor nebo dyn. struktura
                        připravena k použití. 

 
Nastavit přístup k souborům jen pro čtení: 
  
UINT Set_RONLY(void) 
	výstup	kód operace 
	Pozn. Nastavení se nevztahuje na dynamické struktury! 


Nastavit přístup k souborům pro čtení i zápis: 
  
UINT Set_RW(void) 
	výstup	kód operace 
	Pozn. Nastavení se nevztahuje na dynamické struktury! 

 
Přidat záznam: 
  
UINT Add_Rec(void* buf,long len) 
	výstup	kód operace 
	buf	pole k uložení 
	len	počet bajtů k uložení 

 
Nastavit vnitřní ukazatel na první záznam: 
  
UINT First_Rec(void) 
	výstup	kód operace 

 
Nastavit vnitřní ukazatel na další záznam: 
  
UINT Next_Rec(void) 
	výstup	kód operace 

 
Přečíst obsah záznamu: 
  
UINT Read_Rec(void* buf,long maxlen, long* len) 
	výstup	kód operace 
	buf	pole pro uložení přečtených dat 
	maxlen	maximální délka dat v bajtech 
	len	skutečná délka načtených dat v bajtech 

 
Zapsat pole do záznamu:  
  
UINT Write_Rec(void* buf,long len) 
	výstup	kód operace 
	buf	pole obsahující data k uložení do záznamu 
	len	délka dat k uložení 

 
Vložit záznam na aktuální pozici (tj. před stávající aktuální
záznam):  
  
UINT Insert_Rec(void* buf,long len) 
	výstup	kód operace 
	buf	pole obsahující data k uložení do záznamu 
	len	délka dat k uložení 

 
Označit záznam ke zrušení (nastavit bit 0 statusu): 
  
UINT Mark_Rec(void) 
	výstup	kód operace 

 
Ověřit, zda je záznam označen ke zrušení (tj. bit 0 statusu
je nastaven): 
  
BOOL Is_Rec_Marked(void) 
	výstup	TRUE, pokud je bit 1 statusu nastaven. 

 
Zrušit všechny záznamy označené ke zrušení (s nastaveným
bitem 0 statusu): 
  
UINT Delete_Recs(void) 
	výstup	kód operace 

 
Zrušit označení záznamu ke zrušení (nulovat bit 0 statusu): 
  
UINT Undo_Rec(void) 
	výstup	kód operace 

 
Zrušit označení všech záznamů ke zrušení (nulovat bit 0 statusu
všech záznamů): 
  
UINT Undo_Recs(void) 
	výstup	kód operace 

 
Nastavit vnitřní ukazatel na záznam zadaného čísla:  
  
UINT Find_Rec(long num) 
	výstup	kód operace 
	num	pořadové číslo záznamu 

 
Zjistit číslo záznamu, na který je nastaven vnitřní ukazatel:  
  
UINT Get_Rec_Number(long* num) 
	výstup	kód operace 
	num	zjištěné pořadové číslo záznamu 

 
Označit záznam (nastavit bit 1 statusu): 
  
UINT Select_Rec(void) 
	výstup	kód operace 

 
Označit záznam (nastavit status dle zadání): 
  
UINT Select_Rec(char st) 
	výstup	kód operace 
	st	status bity k uložení do záznamu 

 
Zrušit označení záznamu (nulovat bit 1 statusu): 
  
UINT Deselect_Rec(void) 
	výstup	kód operace 

 
Ověřit, zda je záznam označen (tj. bit 1 statusu je nastaven): 
  
BOOL Is_Rec_Selected(void) 
	výstup	TRUE, pokud je bit 1 statusu nastaven. 

 
Nastavit hodnotu parametru:  
  
UINT Set_Parameter(long par) 
	výstup	kód operace 
	par	hodnota parametru, která bude přiřazena
                        k záznamu. 

 
Přečíst hodnotu parametru:  
 
UINT Get_Parameter(long* par) 
	výstup	kód operace 
	par	přečtená hodnota parametru, 
                        která  je přiřazena k záznamu  

 
Zjistit délku záznamu:  
 
UINT Get_Rec_Length(long* len) 
	výstup	kód operace 
	len	zjištěná délka záznamu  

 
Uložit nuly do binárních záznamů a mezery do variabilního
záznamu a řetězce dynamické struktury:  
 
UINT Clear_Rec(void) 
	výstup	kód operace  

 
Zapsat textový řetězec (ukončený nulou) na aktuální pozici:  
 
UINT Write_Rec(void* buf) 
	výstup	kód operace 
	buf	pole textu, který musí být ukončen nulou 

 
Přidat textový řetězec (ukončený nulou) za poslední záznam: 
 
UINT Add_Rec(void* buf) 
	výstup	kód operace 
	buf	pole k uložení  

 
Přečíst délku hlavičky: 
 
UINT Get_File_Header_Length(long *len) 
	výstup	kód operace 
	len	zjištěná délka hlavičky 

 
 Zapsat do souboru hlavičku: 
 
UINT Set_File_Header(void* buf,long len) 
	výstup	kód operace 
	buf	pole s obsahem hlavičky 
	len	délka pole 

 
Přečíst obsah hlavičky ze souboru: 
 
UINT Get_File_Header(void* buf,long maxlen,long* len) 
	výstup	kód operace 
	buf	pole pro uložení hlavičky 
	maxlen	délka rezervovaného pole 
	len	délka načtené hlavičky 

 

Grafika FR4 je reprezentována řetězcem virtuálních kreslicích ploch - obrazovek (screen). V současné verzi je možno v hlavním okně aplikace zobrazit současně pouze jednu obrazovku, lze však mezi obrazovkami přepínat. Celý tento mechanismus se dá připodobnit ke složce s listy papíru (F_graphics), ve které se dají stránky (screen) otáčet, vždy je však viditelná pouze nejvrchnější stránka.

Každá stránka (obrazovka) v FR4 však představuje velkou kreslicí plochu a ne vždy je účelné dívat se na celou tuto plochu najednou. Proto má každá obrazovka definováno aktuální zvětšení a posunutí výřezu - okna - které se zobrazuje. Dále pak každá obrazovka (list ve složce) obsahuje jednu či více vrstev (layer). Vrstvy jsou jako průhledné fólie, na které jde kreslit - umisťovat grafické entity. Vrstvy je možno po jedné dočasně zneviditelnit a opět obnovit jejich zobrazování.

pCORE->AddScreen("papir");

Dalším krokem je přidání alespoň jedné vrstvy, do které budeme kreslit. AddScreen automaticky nastavilo jako aktivní nově přidanou obrazovku, takže přidání vrstvy proběhne do ní:

pCORE->AddLayer("cmaranice");

AddLayer také po přidání nastaví aktivní vrstvu, takže nám už nic nebrání v kreslení entit (viz. podkapitola entity}. Operací nad vrstvami a obrazovkami je však více. Některou z vytvořených vrstev můžeme chtít například zrušit:

pCORE->RemoveLayer("cmaranice");

Pokud budeme ale do vrstvy i nadále kreslit a chceme pouze vymazat její obsah, zavoláme

pCORE->EraseActiveLayer();

Za povšimnutí stojí, že jak u AddLayer, tak i u RemoveLayer se uvádí název vrstvy v rámcí aktivní obrazovky. Většina ostatních funkcí, včetně EraseActiveLayer, však pracuje s aktivní vrstvou. Je proto třeba umět nastavit aktivní vrstvu:

pCORE->SetActiveLayer("cmaranice");

Také pokud máme více obrazovek, lze mezi nimi přepínat:

pCORE->SetActiveScreen("papir");

Jak bylo uvedeno výše, můžeme jednotlivé hladiny dočasně skrývat. K tomu slouží funkce:

pCORE->HideActiveLayer(); a
pCORE->ShowActiveLayer();

Existenci a ev. viditelnost vrstvy jde testovat:

if(pCORE->LayerExists("cmaranice" == STAT_OK) { }
if(pCORE->IsActiveLayerVisible()) { }

Pozor! Zatímco IsActiveLayerVisible() vrací BOOL (TRUE/FALSE), LayerExists (a většina ostatních funkcí) vrací podrobnější popis výsledku operace (např. STAT_OK, kde STAT_OK != TRUE !!!). Proto pozor při testování (if(LayerExist("xxx")) není totéž jako if(LayerExist("xxx") == STAT_OK))!

Nakonec, máme-li vše nastaveno a ve vrstvách jsou umístěny entity, zajistíme si voláním funkce

pCORE->UpdateActiveScreen();

C_WHITE	Bílá (standardně barva pozadí)
C_BLACK	Černá
C_GRAY	Šedá (50%)
C_GRAYDK	Tmavě šedá
C_GRAYLT	Světle šedá
C_RED	Červená
C_GREEN	Zelená
C_BLUE	Modrá
C_YELLOW	Žlutá
C_CYAN	Světle modrá
C_MAGENTA	Fialová

FR4 verze 1.1:

další předdefinované barvy:

C_REDDK	(COLORREF)0x000088
C_GREENDK	(COLORREF)0x008800
C_BLUEDK	(COLORREF)0x880000
C_YELLOWDK	(COLORREF)0x008888
C_CYANDK	(COLORREF)0x888800
C_MAGENTADK	(COLORREF)0x880088
C_DARKSEAGREEN	(COLORREF)0x8fbc8f
C_SEAGREEN	(COLORREF)0x578b2e
C_DARKGREEN	(COLORREF)0x006400
C_ORANGE	(COLORREF)0x00a5ff
C_DARKORANGE	(COLORREF)0x008cff
C_CORAL	(COLORREF)0x507fff
C_TOMATO	(COLORREF)0x4763ff
C_LIGHTCORAL	(COLORREF)0x8080f0
C_CRIMSON	(COLORREF)0x3c14dc
C_CHOCOLATE	(COLORREF)0x1e69d2
C_INDIANRED	(COLORREF)0x5c5ccd
C_FIREBRICK	(COLORREF)0x2222b2
C_BROWN	(COLORREF)0x2a2aa5
C_SADDLEBROWN	(COLORREF)0x13458b
C_DARKRED	(COLORREF)0x00008b
C_PINK	(COLORREF)0xcbc0ff
C_DEEPPINK	(COLORREF)0x9314ff
C_LIGHTGRAY	(COLORREF)0xd3d3d3
C_DARKGRAY	(COLORREF)0xa9a9a9
C_DARKCYAN	(COLORREF)0x8b8b00
C_VIOLET	(COLORREF)0xee82ee
C_LIGHTBLUE	(COLORREF)0xe6d8ad
C_DARKVIOLET	(COLORREF)0xd30094
C_DARKMAGENTA	(COLORREF)0x8b008b
C_BLUEVIOLET	(COLORREF)0xe22b8a
C_CADETBLUE	(COLORREF)0xa09e5f
C_INDIGO	(COLORREF)0x82004b
C_DARKSLATEBLUE	(COLORREF)0x8b3d48
C_STEELBLUE	(COLORREF)0xb48246
C_DEEPSKYBLUE	(COLORREF)0xffbf00
C_DARKBLUE	(COLORREF)0x8b0000
C_FUCHSIA	(COLORREF)0xff00ff
C_AQUA	(COLORREF)0xffff00
C_LIME	(COLORREF)0x00ff00
C_SILVER	(COLORREF)0xc0c0c0
C_OLIVE	(COLORREF)0x008080
C_PURPLE	(COLORREF)0x800080
C_MAROON	(COLORREF)0x000080
C_TEAL	(COLORREF)0x808000
C_NAVY	(COLORREF)0x800000
C_IVORY	(COLORREF)0xf0ffff
C_SNOW	(COLORREF)0xfafaff
C_ANTIQUEWHITE	(COLORREF)0xd7ebfa
C_WHITESMOKE	(COLORREF)0xf5f5f5
C_BEIGE	(COLORREF)0xdcf5f5
C_AZURE	(COLORREF)0xfffff0
C_LIGHTCYAN	(COLORREF)0xffffe0
C_AQUAMARINE	(COLORREF)0xd4ff7f
C_LIGHTYELLOW	(COLORREF)0xe0ffff
C_GOLD	(COLORREF)0x00d7ff
C_KHAKI	(COLORREF)0x8ce6f0
C_GREENYELLOW	(COLORREF)0x2fffad
C_CORNSILK	(COLORREF)0xdcf8ff
C_YELLOWGREEN	(COLORREF)0x32cd9a
C_LIGHTGREEN	(COLORREF)0x90ee90

<Odkaz na tabulku s paletou barev

UINT SetLineStyle(UINT style);

Tuto funkci lze použít např. pokud vykreslujeme v sekvenci za sebou několik entit se stejným typem čáry - ušetří explicitní zápis parametru při volání každé funkce pro kreslení entity. Doplňkovou funkcí k SetLineStyle je

UINT GetLineStyle();

která vrací aktuálně nastavenou hodnotu typu čáry.

Typ čáry může být jedním z následujících:

L_SOLID	Plná tenká čára
L_DASH	Tenká čárkovaná čára
L_DOT	Tenká tečkovaná čára
L_DASHDOT	Tenká čerchovaná čára
L_DBLDOT	Tenká čerchovaná čára s dvojtečkami
L_PHANTOM	Pomocná čára, která se nevykresluje
L_THICK	Středně tlustá plná čára
L_VERYTHICK	Velmi tlustá plná čára

Spolu s tímto identifikačním číslem je též možnost použít další 32bitový parametr, jehož ukládání souvisí s použitím třídy F_dyn pro uchovávání obsahu vrstvy. Před zápisem entity je pro nastavení tohoto parametru potřeba zavolat funkci

void SetEntParam(long i);

UINT Point(double x, double y, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);

UINT Line(double x1, double y1, double x2, double y2, COLORREF col = 0L,long ID=0, UINT style=L_DEFAULT);

Oproti bodu přibyly dva parametry pro koncový bod úsečky. Chceme-li vykreslit lomenou čáru, můžeme použít funkce:

UINT PolyLine(UINT numPoints, double *points, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT, BOOL filled = FALSE);

UINT Circle(double x, double y, double r, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);
UINT Ellipse(double x, double y, double rx, double ry, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);

UINT Polygon(UINT numPoints, double *points, COLORREF col = 0L,long ID=0, UINT style=L_DEFAULT);

UINT InfoText(double x, double y, const char *txt ,COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT, UINT align=T_DEFAULT);

Parametry 'x' a 'y' definují vztažný bod, 'txt' pak řetězec s vypisovaným textem. Oproti ostatním entitám je doplněn parametr 'align' udávající polohu vztažného bodu vůči textu:

T_DEFAULT	Standardní zarovnání v obou směrech
Horizontální zarovnání
T_LEFT	Vlevo
T_CENTER	Uprostřed
T_RIGHT	Vpravo
Vertikální zarovnání
T_TOP	Nahoře
T_BASE	Na spodní lince
T_BOTTOM	Dole
T_MIDDLE	Uprostřed

Druhým druhem textu je text vektorový:

UINT Text(double x, double y, const char *txt ,COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT, UINT align=T_DEFAULT);

Tento text obsahuje znaky vykreslené z jednotlivých čar. Jeho velikost na obrazovce se mění s aktuálním zvětšením. Hodí se např. pro popisy kót na výkrese. Kromě parametrů shodných s informačním textem je navíc ovlivněn i dalšími funkcemi:

void SetTextHeight(double h);
double GetTextHeight();

Nastaví, ev. přečte aktuálně nastavenou výšku textu. Hodnota se udává v jednotkách platných pro celou kreslicí plochu (tedy ve stejných, v jakých je kreslen zbytek konstrukce). Obdobně

void SetTextWidth(double w);
double GetTextWidth();

ovlivňuje šířku výsledného textu. Úhel linky, podél které je text vypisován, se nastaví funkcemi:

void SetTextAngle(double a);
double GetTextAngle();

Posledními funkcemi, ovlivňujícími vzhled vektorového textu, jsou funkce pro nastavení zkosení (náklonu) písma:

void SetTextSlant(double s);
double GetTextSlant();

Úhel u obou posledních funkcí je v radiánech. Pro převod stupňů na radiány můžeme použít makra RAD(x). Opačný převod (z radiánů na stupně) zajišťuje makro DEG(x).

Je-li potřeba z jakýchkoli důvodů zjistit velikost vykreslovaného řetězce při použití vektorového písma, pak lze s výhodou použít funkce:

void CalculateTextRect(double rect[8], UINT align, char *txt, int numCh, double x, double y, double angle, double slant, double height, double width);

Tato funkce zapíše do pole zaslaného parametrem 'rect' souřadnice čtyř vrcholů čtyřúhelníka ohraničujícího text uvedenýc parametrů. V úvahu je přitom brán i sklon a zkosení písma.

Mezi entitami je někdy vhodné zařadit poznámku, která není zobrazována, ale může být užitečná při práci s obsahem vrstvy. Poznámka se zapíše funkcí:

UINT Note(const char *txt, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);

Parametr 'txt' odkazuje na řetězec s obsahem poznámky. Ostatní parametry nemají praktický význam a jsou uvedeny pouze z důvodu zařazení mezi entity.

Zvětšení a posun

UINT SetActiveScreenXPan(double pan);
UINT SetActiveScreenYPan(double pan);
UINT SetActiveScreenZoom(double zoom);

Umožňují posun počátku souřadné soustavy v rámci okna a nastavení násobku zvětšení. Jejich doplňkem pak funkce:

double GetActiveScreenXPan();
double GetActiveScreenYPan();
double GetActiveScreenZoom();

Zvětšení 1 značí, že jedna jednotka virtuální zobrazovací plochy odpovídá jednomu pixelu na obrazovce.

Posun a zvětšení obvykle nastavuje uživatel. Daleko častěji je však z kódu výhodné nastavit takové zvětšení a posun, aby byl celý obrázek vidět a optimálně zabíral plochu okna. To se provede funkcí:

UINT SetActiveScreenZoomAll();

Požadujeme-li, aby byl v okně zobrazen přesně zadaný výřez kleslicí plochy, použijeme funkci:

UINT SetActiveScreenWindow(double x1, double y1, double x2, double y2);

Neodpovídají-li poměry stran zadaného výřezu oknu na obrazovce počítače, je zobrazení provedeno tak, aby byly vidět všechny části zvoleného okna.

Každý záznam v tabulce reprezentuje jednu grafickou entitu. Všechny entity mají stejný začátek záznamu:

typ	název	popis
char	type	typ entity (viz. dále)
long	ID	ID entity (viz. entity)
COLORREF	color	barva entity
UINT	style	druh čáry pro vykreslení entity

Společnou číst záznamu popisuje též struktura gr_item (viz. FR4Ctrl.h). Od tohoto společného základu jsou odvozeny jednotlivé grafické entity podle hodnoty položky 'type':

• P (point, gr_point)

• L (line, gr_line)

• C (circle gr_circle)

• E (ellipse, gr_ellipse)

• O (polyline, gr_polyline)

• F (polygon, gr_polyline)

• I (infotext, gr_infotext)

• T (text, gr_text)

• N (note)

UINT SetActiveScreenToBe3D(BOOL be3D = TRUE);

UINT Point3D(double x, double y, double z, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);
UINT Line3D(double x1, double y1, double z1, double x2, double y2, double z2, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);
UINT PolyLine3D(UINT numPoints, double *points, COLORREF col = 0L,long ID=0, UINT style=L_DEFAULT, BOOL filled = FALSE);
UINT Polygon3D(UINT numPoints, double *points, COLORREF col = 0L,long ID=0, UINT style=L_DEFAULT);
UINT InfoText3D(double x, double y, double z, const char *txt ,COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT, UINT align=T_DEFAULT);


Vektorový text nemá ve 3D svou obdobu. Elipsy a kružnice se ve 3D objevují ve formě značek. Takovéto objekty mají definován střed ve třech rozměrech, avšak poloměr(y) je (jsou) vztažen(y) k zobrazovací rovině. Nejde tedy o plnohodnotné trojrozměrné entity.

UINT CircleMark3D(double x, double y, double z, double r, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);
UINT EllipseMark3D(double x, double y, double z, double rx, double ry, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);


Pro definici kružnice či oblouku v obecné poloze ve 3D se používají funkce, které tyto entity popisují pomocí tří bodů na jejich obvodu:

UINT Circle3D(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);
UINT Arc3D(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, COLORREF col = 0L, long ID=0, UINT style=L_DEFAULT);

UINT SetActiveLayerRegen(CString regen);

Parametrem je název modulu a číslo funkce, např. 'mydll:4'. Dojde-li ke změně pohledu, jádro zavolá regenerátor postupně pro každou vrstvu obrazovky. Úkolem regenerátoru je pak smazat stávající obsah vrstvy a znovu vrstvu naplnit. Regenerace celé obrazovky proběhne také po zavolání funkce RegenerateActiveScreen. Následující příklad demonstruje obsah regenerátoru, který zobrazí osový kříž a to tak, že je uprostřed obrazovky a optimálně zvětšený:

Nastavení úhlu pohledu je v FR4 omezeno na zadání poledníku a rovnoběžky pohledu. Rotace podle zbývající osy není podporována (nemá při zobrazení konstrukce praktické použití).

Poledník a rovnoběžku můžeme zadat buď společně funkcí

UINT SetActiveScreenViewpoint(double lon, double lat);

nebo zvlášť délku a šířku funkcemi

UINT SetActiveScreenLon(double lon);
UINT SetActiveScreenLat(double lat);

Aktuální polohu lze zjistit funkcemi

double GetActiveScreenLon();
double GetActiveScreenLat();

Pro přesné nastavení pohledu podél os slouží funkce

UINT SetActiveScreenViewpoint(UINT vp);

jejímž parametrem je kód zvoleného pohledu:

VP_XPLUS	Pohled z osy X+
VP_XMINUS	Pohled z osy X-
VP_YPLUS	Pohled z osy Y+
VP_YMINUS	Pohled z osy Y-
VP_ZPLUS	Pohled z osy Z+
VP_ZMINUS	Pohled z osy Z-

Pozn.: Systém FR4 používá k zobrazení systém, kde vodorovná rovina je definovaná osami X a Y. Osa Z je svislá a její kladný směr je dolů od roviny XY, záporný směr nahoru od XY.

Předchozí nastavení pohledu (ale i zvětšení a posunu) je v grafice FR4 zapamatováno, takže ho můžeme funkcí

void UndoActiveScreenViewpoint();

obnovit.

Grafika FR4 má též podporu pro technická zobrazení (vybrané druhy axonometrických zobrazení). Nastavení použití těchto zobrazení a čtení aktuálního stavu dosáhneme voláním funkcí

UINT SetActiveScreenAxo(UINT axo);
UINT GetActiveScreenAxo();

Význam parametru je následující:

VT_NONE	bez axonometrie (použití axonometrie vypnuto)
VT_KOSDIM	kosoúhlá dimetrie
VT_ITAAXO	italská axonometrie
VT_KAVALAXO	kavalírní axonometrie

void ShowCrossHair(UINT chType = CH_CROSSHAIR, BOOL clip=FALSE);

První parametr popisuje typ nitkového kurzoru a může mít jednu z následujících hodnot:

CH_CROSSHAIR	běžný nitkový kříž (dvě kolmé křížící se čáry, zadávací)
CH_CIRCLE	nitkový kříž s kroužkem uprostřed
CH_BOX	nitkový kříž se čtverečkem uprostřed (výběrový)
CH_PHANTOM	'neviditelný' kříž (kurzor nezobrazován)

Druhý parametr (clip) značí 'uvěznění' kurzoru uvnitř zadávacího okna (běžně se nepoužívá, proto FALSE).

Vykreslování nitkového kurzoru se vypne po zavolání funkce:

void HideCrossHair();

 
#define REGISTER_LB_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_RB_HANDLER(thatclassname,
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_LD_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_RD_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_LU_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_RU_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define REGISTER_MM_HANDLER(thatclassname, 
    thisclassname, thisfcename, recStat, retValNam) 
#define GO_GET_LINE(thatclassname, thisclassname, 
    thisfcename, recStat, retValNam) {\ 
void DeregisterHandlers(void *Othis=NULL); 

zobrazovat (bodovou) mřížku

 
UINT ShowGrid(BOOL show); 

stav zobrazování mřížky

 
BOOL GetGridStatus(); 

nastavit krok mřížky v ose x

 
UINT SetGridXStep(double x);

nastavit krok mřížky v ose y

  
UINT SetGridYStep(double y); 

zjistit krok mřížky v ose x

 
double GetGridXStep(); 

zjistit krok mřížky v ose y

 
double GetGridYStep(); 

Při práci s FR4 grafikou je třeba mít na paměti, že všechny grafické entity definované pomocí popisovaných funkcí, jsou nejdříve ukládány do struktur, a teprve na povel je možné je vykreslit (pozn. ve zvláštním režimu grafiky dochází k okamžitému vykreslování generovaných entit). Po vykreslení jsou 2D entity stále uloženy ve strukturách a lze je proto zobrazit nezávisle na generujících algoritmech s jiným zvětšením a v jiné poloze. Uložené entity lze měnit nebo rušit. Dělení obrázků do vrstev usnadňuje dodatečnou manipulaci s entitami. Základní postup vytvoření kresby je popsán v následujícím příkladě:

1. Vytvoříme obrazovku

Fdis->AddScreen("obrazovka");

2. Vytvoříme vrstvu

Fdis->AddLayer("prvni vrstva"); 

Pozn. Každá vrstva je reprezentována jednou položkou v projektu. Typ položky projektu je 'graphics', podtyp 'layer', skupina je stejná jako název obrazovky, do které vrstva náleží. Nazev položky je /, v našem případě tedy 'moje obrazovka/prvni vrstva'. Je možno si ji prohlédnout pomocí systémových služeb (sysl.dll).

3. Ukládáme grafické entity do vrstvy, např. úsečku:

 
Fdis->Line(0, 0, 10, 10, RGB(255,0,0)); 

Tento příaz vykreslí čáru z bodu [0,0] do bodu [10,10] barvou (255,0,0) (červená). Identifikační číslo a typ jsou ponechány na přednastavených hodnotách.

Identifikační číslo (ID) je unikátní číslo, identifikující jednoznačně entitu ve vrstvě (v obrazovce). Je používáno při výběrech entit uživatelem. Typ čáry je jednou z možných přednastavených hodnot (plná, čárkovaná, čerchovaná,... viz. popis fce. Line).
Je-li ponechán typ L_DEFAULT, pak je doplněn aktuálně zvolený typ (funkcí SetLineStyle).

Můžeme přidávat další entity (třeba do další vrstvy):

Fdis->AddLayer("druha vrstva"); 
Fdis->Point(5,0,RGB(0,0,0)); 

Uložené entity můžeme zobrazit.

4. Nastavime parametry zobrazení, např. výřez obrazovky tak, aby bylo nastaveno zvětšení a posunutí tak, aby bylo zobrazeno všechno, co je ve vrstvách umístěno:

Fdis->SetActiveScreenZoomAll();
 

5. Dáme povel k zobrazení uložených entit:

Fdis->UpdateActiveScreen();

Jádro FR4 podporuje přímo pouze 2D grafiku (pozn. s výjimkou režimu práce s OpenGL 3D grafikou). Trojrozměrné objekty jsou převáděny na 2D grafické entity (průměty do 2D) a ukládány stejným způsobem jako entity 2D grafiky. Ke generování musí být připraveny generační funkce, které používají 3D grafické funkce jádra FR4 a jsou upraveny tak, aby je bylo možné kdykoliv volat. Volání generačních funkcí je nutné vždy po rotaci 3D objektu, kdy se vytváří nový průmět objektu. Generační funkce proto musí být v FR4 grafice "registrovány" pomocí funkce:

UINT SetActiveLayerRegen(CString regen); 

1. práce s obrazovkou

nastaví vnitřní ukazatel na první obrazovku 'grafiky'

 
UINT First_screen();  
        vraci: STAT_OK - nastavena první obrazovka 
             STAT_ENDCHAIN - v seznamu není žádná 
             obrazovka

nastaví vnitřní ukazatel na dalši obrazovku 'grafiky'

 
UINT Next_screen();  
        vraci: STAT_OK - nastavena další obrazovka 
             STAT_ENDCHAIN - konec řetězce obrazovek 

přidá obrazovku do seznamu

  
UINT AddScreen(CString name); 
       parametry: name - jméno obrazovky 
       vraci: STAT_OK - obrazovka přidána 
            STAT_CANTCREA - nelze přidat 
            - jméno už existuje 
Pozn. vytvoří obrazovku bez vrstev, posunutí na [0,0],
zvětšení 1, axonometrie VT_KOSDIM, pohled +Y, 3D.

odstraní obrazovku daného jména

 
UINT RemoveScreen(CString name); 
       parametry: name - jméno obrazovky 
       vraci: STAT_OK - obrazovka odebrana 
            STAT_NOTFOUND - nelze zrušit - neexistuje 

vrátí jméno aktivní obrazovky

 
CString GetActiveScreenName(); 
       vraci: jméno obrazovky nebo 
        CString(""), pokud žádná obrazovka neexistuje. 

nastaví aktivní obrazovku

 
UINT SetActiveScreen(CString name); 
      parametry: name - jmeno obrazovky 
      vraci: STAT_OK - obrazovka nastavena 
      STAT_NOTFOUND - nelze nastavit - neexistuje 

zjistí existenci obrazovky

 
UINT ScreenExists(CString name = "");  
       parametry: name - jméno obrazovky 
          bez parametru: dotaz, zda existuje alespoň 
          jedna obrazovka 
       vraci: STAT_OK - obrazovka existuje 
            STAT_NOTFOUND - neexistuje

zajistí zobrazení aktivní obrazovky v zobrazovacím okně

 
void UpdateActiveScreen(BOOL bErase = TRUE); 
       parametry: bErase - smazat stavající obsah 

2. práce se zvětšením a posunutím

vrací posun v ose X

 
double GetActiveScreenXPan(); 
      vrátí x pozici středu zobrazení
      nebo 0, pokud obrazovka neexistuje

vrací posun v ose Y

 
double GetActiveScreenYPan(); 
      vrátí y pozici středu zobrazení
      nebo 0, pokud obrazovka neexistuje

vrátí nastavený faktor zvětšení

 
double GetActiveScreenZoom(); 
     vraci: faktor zvětšení nebo 1, 
     pokud obrazovka neexistuje.

nastaví x pozici středu zobrazení

 
UINT SetActiveScreenXPan(double pan);  
      parametry: pan - x pozice středu 
      vraci: STAT_OK - pozice nastavena 
           STAT_NOTFOUND - obrazovka neexistuje 

nastaví y pozici středu zobrazení

 
UINT SetActiveScreenYPan(double pan); nastavi y 
      parametry: pan - y pozice středu 
      vraci: STAT_OK - pozice nastavena 
           STAT_NOTFOUND - obrazovka neexistuje 

nastaví faktor zvětšení zobrazení

  
UINT SetActiveScreenZoom(double zoom);  
      parametry: zoom - faktor zvětšení 
      vraci: STAT_OK - zvětšeni nastaveno 
           STAT_NOTFOUND - obrazovka neexistuje 

nastaví zvětšení a střed tak, aby byla zobrazena celá kresba v okně grafiky

 
UINT SetActiveScreenZoomAll(); 
       vraci: STAT_OK - posun a zvětšení nastaveno 
            STAT_NOTFOUND - obrazovka neexistuje

nastaví zvětšení a střed tak, aby byl zobrazen daný výřez kresby

 
UINT SetActiveScreenWindow(double x1, double y1, 
          double x2, double y2); 
        parametry: x1,y1,x2,y2 - souřadnice rohu 
             výřezu 
        vraci: STAT_OK - posun a zvětšení nastaveno 
             STAT_NOTFOUND - obrazovka neexistuje

3. práce s vrstvami

nastaví vnitřní ukazatel na první vrstvu 'obrazovky'.

 
UINT First_layer(); 
         vraci: STAT_OK - nastavena prvni vrstva 
                STAT_ENDCHAIN - v seznamu neni žádná vrstva

nastaví vnitřní ukazatel na další vrstvu 'obrazovky'.

 
 
UINT Next_layer(); 
        vraci: STAT_OK - nastavena další vrstva 
               STAT_ENDCHAIN - konec řetězce vrstev

nastavení aktivní vrstvy.

 
UINT SetActiveLayer(CString layer);
       vraci: STAT_OK - vrstva nastavena 
             STAT_NOTFOUND - nelze nastavit - neexistuje

vratí jméno aktivní vrstvy

 
CString GetActiveLayerName(); 
       vraci: jméno vrstvy nebo CString(""),
             pokud žádná vrstva neexistuje.

vrátí status aktivní vrstvy

 
long GetActiveLayerStatus();
        vraci: status vrstvy nebo 0, 
               pokud vrstva ci obrazovka neexistuje.

nastavi status aktivni vrstvy

 
UINT SetActiveLayerStatus(long stat);  
          parametry: stat - status vrstvy (viz. Dodatek A) 
          vraci: STAT_OK - status nastaven 
                STAT_NOTFOUND - nelze nastavit
                - vrstva ci obrazovka neexistuje 

přidá novou vrstvu k aktualní obrazovce

 
UINT AddLayer(CString name, long stat=FL_VISIBLE); 
         parametry: name - jméno vrstvy 
                      stat - status vrstvy 
                      (viz. Dodatek A) 
         vraci: STAT_OK - vrstva vytvořena 
              STAT_CANTCREA - vrstva daného jména už 
              existuje 
              STAT_NOTFOUND - obrazovka neexistuje jiný 
              STAT_ - viz.F_dyn::Open_File().
 

zruší vrstvu daného jména

 
UINT RemoveLayer(CString name);
         parametry: name - jméno vrstvy 
         vraci: STAT_OK - vrstva vytvořena 
                STAT_NOTFOUND - obrazovka či vrstva 
                 neexistuje 
Pozn. pokud je vrsva vytvořena funkcí DisplayLayer, 
není tabulka s entitami vrstvy smazána.

zjistí existenci vrstvy daného jména

UINT LayerExists(CString name = "");
          parametry: name - jméno vrstvy 
              bez parametru: existuje alespoň jedna
              vrstva v obrazovce?
          vraci: STAT_OK - vrstva existuje 
                 STAT_NOTFOUND - vrstva neexistuje

smaze obsah aktivni vrstvy

UINT EraseActiveLayer(); 
         vraci: STAT_OK - vrstva existuje 
              STAT_NOTFOUND - vrstva neexistuje 
              STAT_CANTCREA - vrstvu nelze vytvořit 
              jiny STAT_ - viz.F_dyn::Open_File(). 
Pozn. nevolejte tuto funkci na vrstvu vytvořenou pomocí
DisplayLayer. Používejte ve funkcích zavěšených na
překreslení 3D, raději než RemoveLayer().

nastavií status aktivní vrstvy na viditelnou

UINT ShowActiveLayer(); 
        vraci: STAT_OK - status nastaven 
             STAT_NOTFOUND - nelze nastavit 
             - vrstva či obrazovka neexistuje

zneviditelní aktivní vrstvu (vypne její zobrazovaní)

UINT HideActiveLayer();  
        vraci: STAT_OK - status nastaven 
             STAT_NOTFOUND - nelze nastavit - vrstva 
                či obrazovka neexistuje

status viditelnosti aktivni vrstvy

BOOL IsActiveLayerVisible(); 
       vraci: TRUE - vrstva je viditelna 
             FALSE - vrstva neni viditelna

povolí výběr v aktivní vrstvě

UINT EnableActiveLayerSelect(); 
       vraci: STAT_OK - status nastaven 
            STAT_NOTFOUND - nelze nastavit 
            - vrstva či obrazovka neexistuje

zakáže výběr v aktivní vrstvě

UINT DisableActiveLayerSelect(); 
        vraci: STAT_OK - status nastaven 
             STAT_NOTFOUND - nelze nastavit 
             - vrstva či obrazovka neexistuje

status selekovatelnosti aktivní vrstvy

BOOL IsActiveLayerSelectable();  
       vraci: TRUE - vrstva je selekovatelná 
             FALSE - vrstva není selekovatelná 

4. práce s 3D

 
UINT RegenerateActiveScreen(BOOL erase = TRUE);
UINT SetActiveScreenViewpoint(double lon, double lat);
UINT SetActiveScreenLon(double lon); 
UINT SetActiveScreenLat(double lat); 
double GetActiveScreenLon();
double GetActiveScreenLat(); 
UINT SetActiveScreenViewpoint(UINT vp); 
UINT SetActiveLayerRegen(CString regen); 
CString GetActiveLayerRegen(); 
UINT SetActiveScreenAxo(UINT axo);
UINT GetActiveScreenAxo();
UINT RecalcActiveScreenVisibleBounds(BOOL repaint = FALSE);
UINT SetActiveScreenToBe3D(BOOL be3D = TRUE);

5. práce s entitami (2D)

převod fyzických souřadnic polohy myši do souřadnic 2D průmětu (obrazovky)

BOOL TransformMouseTo2D(CPoint p,double *xx,
                        double *yy); 

převod fyzických souřadnic polohy myši do siuřadnic 2D přůmetu (obrazovky) se zaokrouhlenim souřadnic do mžížky

BOOL TransformSnappedMouseTo2D(CPoint p,double *xx,double *yy); 

převod souřadnic 2D (obrazovky) do fyzických souřadnic myši

BOOL Transform2DtoMouse(CPoint *p, double x, double y); 

nastavení stylu čar

UINT SetLineStyle(UINT style);

přečtení nastaveného stylu čar

UINT GetLineStyle();

2D bod

UINT Point(double x, double y, COLORREF col, 
                        long ID=0, UINT style=L_DEFAULT);

2D úsečka

UINT Line(double x1, double y1, double x2, double y2,
                        COLORREF col,long ID=0, 
                        UINT style=L_DEFAULT); 

2D kružnice

UINT Circle(double x, double y, double r, COLORREF col,
                        long ID=0, UINT style=L_DEFAULT); 

2D elipsa s osami rovnoběžnými s osami x a y obrazovky

UINT Ellipse(double x, double y, double rx, double ry, 
                        COLORREF col, long ID=0, 
                        UINT style=L_DEFAULT); 

2D polyline

UINT PolyLine(UINT numPoints, double *points, 
                        COLORREF col,long ID=0, 
                        UINT style=L_DEFAULT, 
                        BOOL filled = FALSE); 

2D polygon (nemusí být uzavřený)

UINT Polygon(UINT numPoints, double *points, 
                        COLORREF col,long ID=0, 
                        UINT style=L_DEFAULT); 

informační text konstantní velikosti bez ohledu na zvětšení obrázku

UINT InfoText(double x, double y, const char *txt ,
                        COLORREF col, long ID=0, 
                        UINT style=L_DEFAULT);

zjistit hodnotu parametru pro nastavení výšky textu

double GetTextHeight(); 

nastavit parametr určující výšku textu

void SetTextHeight(double h); 

zjistit hodnotu parametru pro nastavení šířky textu

double GetTextWidth(); 

nastavit parametr určující šířku textu

void SetTextWidth(double w) {twidth = w;}; 

zjistit hodnotu parametru pro nastavení směru textu

double GetTextAngle(); 

nastavit parametr určující směr textu

void SetTextAngle(double a); 

zjistit hodnotu parametru pro nastavení sklonu textu

double GetTextSlant(); 

nastavit parametr určující sklon textu

void SetTextSlant(double s); 

nastavení parametru grafické entity

void SetEntParam(long i); 

výpočet obdélníka, ve kterém se nachází zadaný text

void CalculateTextRect(double rect[8], UINT align, 
                        char *txt, int numCh, 
                        double x, double y,
                        double angle, double slant, 
                        double height, double width); 

2D text

UINT Text(double x, double y, const char *txt ,
                         COLORREF col = 0L, long ID=0,
                         UINT style=L_DEFAULT, 
                         UINT align=T_DEFAULT); 

poznámka, které není v obrázku viditelná

UINT Note(const char *txt, COLORREF col = 0L,
                         long ID=0, UINT style=L_DEFAULT); 

6. práce s entitami (3D)

transformace bodu (x,y,z) do souřadnic obrazovky (xx,yy)

 

void Transform3Dto2D(double x,double y,double z,
                         double *xx,double *yy); 

bod o souřadnicích x,y,z

 

UINT Point3D(double x, double y, double z, COLORREF col,
                         long ID=0, UINT style=L_DEFAULT);

úsečka z bodu x1,y1,z1 do bodu x2,y2,z2

UINT Line3D(double x1, double y1, double z1, 
                double x2, double y2, double z2, 
                COLORREF col = 0L, long ID=0, 
                UINT style=L_DEFAULT); 

oblouk v prostoru z bodu x1,y1,z1 přes bod x2,y2,z3 do bodu x3,y3,z3

 

UINT Arc3D(double x1, double y1, double z1, 
                   double x2, double y2, double z2, 
                   double x3, double y3, double z3, 
                   COLORREF col = 0L, long ID=0, 
                   UINT style=L_DEFAULT); 

kružnice v prostoru z bodu x1,y1,z1 přes bod x2,y2,z3 do bodu x3,y3,z3

 

UINT Circle3D(double x1, double y1, double z1, 
                   double x2, double y2, double z2, 
                   double x3, double y3, double z3, 
                   COLORREF col = 0L, long ID=0, 
                   UINT style=L_DEFAULT); 

 

UINT PolyLine3D(UINT numPoints, double *points,
                         COLORREF col = 0L,long ID=0, 
                         UINT style=L_DEFAULT,
                         BOOL filled = FALSE); 

 

UINT Polygon3D(UINT numPoints, double *points,
                         COLORREF col,long ID=0, 
                         UINT style=L_DEFAULT); 

v prostoru umístěný text

UINT Text3D(double x, double y, double z, 
                    const char *txt , 
                    double lon = 0.0, double lat = 0.0, 
                    COLORREF col = 0L, long ID = 0L,
                    UINT style = L_DEFAULT,
                    UINT align = T_DEFAULT); 

kružnice jako značka ( v rovině obrazovky )

 

UINT CircleMark3D(double x, double y, double z, 
                   double r, COLORREF col = 0L, 
                   long ID=0, UINT style=L_DEFAULT); 

elipsa jako značka ( v rovině obrazovky )

 

UINT EllipseMark3D(double x, double y, double z, 
            double rx, double ry, COLORREF col = 0L, 
            long ID=0, UINT style=L_DEFAULT); 

text jako značka ( v rovině obrazovky )

 

UINT InfoText3D(double x, double y, double z, 
                    const char *txt ,COLORREF col,
                    long ID=0, UINT style=L_DEFAULT);

7. práce s kurzorem

zobrazit kurzor

 
void ShowCrossHair(UINT chType = CH_CROSSHAIR,
       BOOL clip=FALSE);

zrusit zobrazení kurzoru

 
void HideCrossHair();

levé tlačítko - dolů

 
UINT RegisterLBHandler(void *LBt, FRBCB addr,
       BOOL recStat = FALSE); 

pravě tlačítko - dolů

 
UINT RegisterRBHandler(void *RBt, FRBCB addr, 
       BOOL recStat = FALSE);

levé tlačítko - dvakrát

 
UINT RegisterLDHandler(void *LBt, FRBCB addr,
       BOOL recStat = FALSE); 

pravé tlačítko - dvakrát

 
UINT RegisterRDHandler(void *RBt, FRBCB addr, 
       BOOL recStat = FALSE);

levé tlačítko - nahoru

 
UINT RegisterLUHandler(void *LBt, FRBCB addr,
       BOOL recStat = FALSE);

pravé tlačítko - nahoru

 
UINT RegisterRUHandler(void *RBt, FRBCB addr, 
       BOOL recStat = FALSE); 

pohyb myši

 
UINT RegisterMMHandler(void *RBt, FRMCB 
       addr, BOOL recStat = FALSE); 

definování úsečky

 
UINT GoGetLine(void *Lt , FRLCB addr, 
        BOOL recStat = FALSE); 

zrušení registrace zadaného objektu

 
void DeregisterHandlers(void *Othis=NULL); 

8. geometrické funkce

 
long GetNearestIDinLayer(double x, double y, double r);
double DistPoint2Point(double x1, double y1, double x2, double y2);
double DistPoint2Line(double x, double y, double x1, double y1,
                        double x2, double y2);
double DistPoint2Circle(double x, double y, double x1, double y1,
                        double r1); 
BOOL DoLinesIntersect(double x1, double y1, double x2, double y2,
                        double x3, double y3, double x4, double y4);
BOOL LineIntersection(double x1, double y1, double x2, double y2, 
                        double x3, double y3, double x4, 
                        double y4, double *x, double *y); 
BOOL IsPointProjectOnLine(double x, double y, double x1, 
                        double y1, double x2, double y2);

Konstanty a makra

EPS - epsilon 
PI - Ludolfovo cislo 
RAD(x) - prevod cisla x ze stupnu na radiany 
DEG(x) - prevod cisla x z radianu na stupne

Status vrstvy (lze kombinovat)

FL_VISIBLE - vrstva je viditelna 
FL_SELECTABLE - ve vrstve lze vybirat entity funkcemi pro vyber 
FL_READONLY - obsah vrstvy je pouze pro cteni (viz. fce. DisplayLayer)

Druhy axonometrii (nelze kombinovat)

VT_NONE - bez axonometrie 
VT_KOSDIM - kosouhla dimetrie (default) 
VT_ITAAXO - italska axonometrie 
VT_KAVALAXO - kavalirni axonometrie

Předdefinované pohledy ze směru os (nelze kombinovat)

VP_XPLUS - pohled z X+ 
VP_XMINUS - pohled z X-
VP_YPLUS - pohled z Y+ 
VP_YMINUS - pohled z Y- 
VP_ZPLUS - pohled z Z+ 
VP_ZMINUS - pohled z Z-

Druhy čar (nelze kombinovat)

L_DEFAULT - standardni (viz. fce. Line) 
L_SOLID - plna cara _________________
L_DASH - carkovana _ _ _ _ _ _ _ _ _ 
L_DOT - teckovana ................. 
L_DASHDOT - cerchovana _._._._._._._._._ 
L_DBLDOT - dvojteckovana _.._.._.._.._.._. 
L_PHANTOM - neviditelna 
L_THICK - tlusta ================= 
L_VERYTHICK - velmi tlusta EEEEEEEEEEEEEEEEE

FR4 verze 1.1 :
// ISO/DIS 12011-1 line types 
L_ISO_01_1	1 
L_ISO_01_1B	9       -----------v^--------- 
L_ISO_01_2	7 
L_ISO_01_3	8 
L_ISO_02_1	10     ----   ----   ----   ---- 
L_ISO_02_2	11     ====   ====   ====   ==== 
L_ISO_02_3	12     EEEE   EEEE   EEEE   EEEE 
L_ISO_07	13      . . . . . . . . . . . . . 
L_ISO_08_1	14      --- - --- - --- - --- - --- 
L_ISO_08_2	15      === = === = === = === = === 
L_ISO_08_3	16      EEE E EEE E EEE E EEE E EEE 
L_ISO_09_1	17      --- - - --- - - --- - - --- 
L_ISO_09_2	18      === = = === = = === = = === 
L_ISO_09_3	19      EEE E E EEE E E EEE E E EEE  

Předdefinované typy kurzoru

CH_NONE - kurzor vypnut (není stejné jako CH_PHANTOM) 
CH_CROSSHAIR - nitkový kříž ----|---- 
CH_CIRCLE - kříž s kroužkem ----o---- 
CH_BOX - kříž se čtverečkem ----[]--- 
CH_PHANTOM - neviditelný kurzor (zapnutý)

FR4 verze 1.1 :
CH_SIZE     5    no crosshair, size arrow all directions 
CH_ROT      6    no crosshair, rot arrow all directions 

F_graphics();
 ~F_graphics(); 
void OnDrawFromBuffer(CDC* pDC); // public 
draw function void OnEraseGraphicsBkgrnd();
void SetDisplayWindow(CWnd *wnd);
void DestroyGraphics();
void OnTrackMouseMove(UINT nFlags, CPoint point);
void OnLBDown(UINT nFlags, CPoint point);
void OnRBDown(UINT nFlags, CPoint point);
void OnLBDouble(UINT nFlags, CPoint point);
void OnLBUp(UINT nFlags, CPoint point); 
void OnRBDouble(UINT nFlags, CPoint point);
void OnRBUp(UINT nFlags, CPoint point);
UINT DisplayLayer(CString name, long stat=FL_VISIBLE);

2D grafické entity:

struct gr_item { char type; long ID; COLORREF color; UINT style; }; 
struct gr_point : public gr_item { double x,y; }; 
struct gr_line : public gr_item { double x1,y1,x2,y2; }; 
struct gr_circle : public gr_point { double r; };
struct gr_ellipse : public gr_point { double rx,ry; };
struct gr_polyline : public gr_item { UINT numPoints; 
             // the array of x-y pairs of double follows };
struct gr_infotext : public gr_point { UINT numChars; 
             // the array uf characters follows };

typedef void (CALLBACK *FRBCB)(F_dispatch* dis,UINT nFlags,
              CPoint p, double x, double y, BOOL finish);
typedef void (CALLBACK *FRMCB)(F_dispatch* dis,CDC *pDC,
              CPoint p, BOOL finish);
typedef void (CALLBACK *FRLCB)(F_dispatch* dis,double x1,
               double y1, double x2, double y2, BOOL finish);
 

chain of layers

struct F_layer_chain { 
               struct F_layer_chain *chain; 
               F_dyn *layer; 

               long status; 
               CString regenerator; };

chain of graphs

struct F_graph_chain { 
    struct F_graph_chain *chain; 
    struct F_layer_chain *layers;
    struct F_layer_chain *layers_A; 
    CString name; 

    double PX,PY,ZV; 

     double XMAX,YMAX,XMIN,YMIN; 

     double Slon,Clon,Slat,Clat; 

     UINT axo;
     BOOL viewIs3D; 
};

chain of views

struct F_view_chain {
                  struct F_view_chain *chain; 
                  CView *view; 
                  CString name; };