TVarList - Zastosowanie
C++
Bot Smart-Spam - Fragment kodu źródłowego
/**
* Zwraca dane usera na podstawie loginu
*/
private Dictionary<string, string> GetUserInfo(string login)
{
var UserData = new Dictionary<string, string>();
String HTML = web.DownloadString("http://example.com/user/" + login + "/");
string reg;
Match match;
// Konto zamkni
reg = @"h2>Konto zamkni";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
{
UserData["state"] = "BANNED";
return UserData;
}
UserData["state"] = "ADDED";
// Join date
reg = @"Posty od:\s*<\td>\s*<td.*?>\s*(?<day>\d+) (?<month>\w+) (?<year>\d+) o (?<hour>\d+:\d+)\s*<\td>";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
{
UserData["join_date"] = MakeDate(match.Groups[1].Value,
match.Groups[2].Value,
match.Groups[3].Value,
match.Groups[4].Value);
}
// Last active date
reg = @"Ostatnio:\s*<\td>\s*<td.*?>\s*(?<day>\d+) (?<month>\w+) (?<year>\d+) o (?<hour>\d+:\d+)\s*<\td>";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
{
UserData["last_date"] = MakeDate(match.Groups[1].Value,
match.Groups[2].Value,
match.Groups[3].Value,
match.Groups[4].Value);
}
// GG
reg = @"gg:(\d+)";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
UserData["gg"] = match.Groups[1].Value;
else
UserData["gg"] = "0";
// Posty na główne/poczekalni
reg = @"wnej:\s*(\d+)\s*z\s*(\d+)\s*/li>";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
{
UserData["count_glowna"] = match.Groups[1].Value;
UserData["count_poczekalnia"] = Convert.ToString(Convert.ToInt32(match.Groups[2].Value) -
Convert.ToInt32(match.Groups[1].Value));
}
// Liczba komentarzy
reg = @"omentarzy: (\d+)/li>";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
UserData["count_comments"] = match.Groups[1].Value;
// Tytuł postu z glownej
UserData["glowna_title"] = "";
if (Convert.ToInt32(UserData["count_glowna"]) > 0)
{
reg = @"h1 class=""picture"">(.*?)/h1>";
match = (new Regex(reg, RegexOptions.Multiline)).Match(HTML);
if (match.Success)
{
StringWriter myWriter = new StringWriter();
HttpUtility.HtmlDecode(match.Groups[1].Value, myWriter);
UserData["glowna_title"] = myWriter.ToString().Trim();
}
}
return UserData;
}
Dex Framework - Fragment kodu źródłowego
require_once ROOT_PATH . 'lib/DexEngine/Debug/DBG.php';
require_once ROOT_PATH . 'lib/DexEngine/DexController.php';
require_once ROOT_PATH . 'lib/DexEngine/DexRouter.php';
require_once ROOT_PATH . 'lib/DexEngine/DexLayout.php';
require_once ROOT_PATH . 'lib/DexEngine/DB/DexTable.php';
class DexApp
{
private static $instance;
/**
* Lista uruchomionych kontrolerów
* @var array of DexController
*/
private static $controllerList = array();
/**
* @var DexLayout
*/
public $layout;
/**
* @var DexController
*/
public $frontController;
/**
* @var DexRouter
*/
public $router;
/**
*
* @return DexApp
*/
public static function getInstance()
{
if(!isset(self::$instance))
self::$instance = new self();
return self::$instance;
}
/**
*
* @return type
*/
function __construct()
{
self::$instance = $this;
DBG::init();
$this->router = DexRouter::getInstance();
$this->layout = DexLayout::getInstance();
// W trybie debugowania nigdy nie wczytuj danych z pliku cache
// W normalnym trybie staraj się wczytać z cache
if(DEBUG || !$this->router->LoadFromCache())
{
$this->router->LoadData(APP_PATH . 'routes.php');
}
$_GET = $this->router->rewrite();
$this->_init();
// front controller
$this->frontController = DexController::create($_GET['controller'] . 'Controller');
if(!$this->frontController)
{
// $_GET['action'];
DBG::error("Nie odnaleziono kontrolera");// or redirect
die("Nie odnaleziono kontrolera");
return;
}
else
$this->layout->view->content = $this->frontController->runAction($_GET['action'] . 'Action');
echo $this->layout->render();
}
/**
* Dodaj nowy kontroler do listy kontrolerów
*
* @param DexController
* @return void
*/
public static function addControler(DexController &$controllerObject)
{
self::$controllerList[$controllerObject->name] = $controllerObject;
}
/**
* Dodaj nowy kontroler do listy kontrolerów
*
* @param string nazwa kontrolera
* @return DexController|null
*/
public static function getControler($name)
{
return isset(self::$controllerList[$name])? self::$controllerList[$name] : null;
}
/**
*
* @return type
*/
function _init() {}
function _initHeaders() {}
}
Potomkowie Adama i Ewy - Kod źródłowy
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Text.RegularExpressions;
using System.IO;
namespace Drzewo_Adama
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
const int Max = 91;
private void button1_Click(object sender, EventArgs e)
{
// Stwórz katalog na pliki
String ścieżka = Directory.GetCurrentDirectory() + @"\HTM";
Directory.CreateDirectory(ścieżka);
using (WebClient webKlient = new WebClient()) // Tworzymy połączenie
{
progressBar1.Maximum = Max;
// Ściągamy pliki
for (int i = 1; i <= Max; i++)
{
progressBar1.Value = i;
String nazwaPliku = "pafg" + (i < 10 ? "0" : "") + i.ToString() + ".htm";
String kodHTML = webKlient.DownloadString("http://www.marshallgenealogy.org/bible/" + nazwaPliku);
// Wstępna obróbka plików
Boolean PołączPliki = kodHTML.IndexOf("<h4 align=center>(Continued)</h4>") > -1;
// Pomijamy nagłówek i stopkę strony
int start = kodHTML.IndexOf("<hr>"); // Len = 5
int koniec = kodHTML.IndexOf("<p align=center>");
kodHTML = kodHTML.Substring(start + 5, koniec - start - 5);
if (PołączPliki)
{
File.WriteAllText(ścieżka + "\\" + nazwaPliku, "");
String nazwaPlikuNiepustego = "";
for (int j = i - 1; j > 0; j--)
{
nazwaPlikuNiepustego = "pafg" + (j < 10 ? "0" : "") + j.ToString() + ".htm";
String tmpHTML = File.ReadAllText(ścieżka + "\\" + nazwaPlikuNiepustego);
if (tmpHTML.Length > 0) // Dołącz do pierwszego niepustego pliku
{
File.WriteAllText(ścieżka + "\\" + nazwaPlikuNiepustego, tmpHTML + kodHTML);
break;
}
else File.WriteAllText(ścieżka + "\\" + nazwaPlikuNiepustego, "");
}
}
else
{
File.WriteAllText(ścieżka + "\\" + nazwaPliku, kodHTML);
}
}
}
MessageBox.Show("Zakończono pobieranie plików!");
}
private void button2_Click(object sender, EventArgs e)
{
/******** Przetwarzamy pobrane dane *********/
const string REG_IMIĘ_RODZICA = "^<b>\\s*<a name=\"[\\d\\w\\s\\-]*\">\\s*</[<>\\w\\s\\.\\#\"\\=]*>([\\w \\(\\)\\*]+)</";
const string REG_IMIĘ_DZIECKA = "<td><[\\w\\s\\=<>\"\\.\\#\\/\\-]+([a-b]{1})>([\\w \\(\\)\\*]+)</b>";
drzewo.Nodes.Clear();
String ścieżka = Directory.GetCurrentDirectory() + @"\HTM";
Action<Int32, List<TreeNode>> BudujDrzewo = (generacja, tatusiowie) => { };
BudujDrzewo = (generacja, tatusiowie) =>
{
String nazwaPliku;
String kodHTML;
do
{
progressBar1.Value = ++generacja;
nazwaPliku = "pafg" + (generacja < 10 ? "0" : "") + generacja.ToString() + ".htm";
if (!File.Exists(ścieżka + "\\" + nazwaPliku))
{
MessageBox.Show("Brak pliku: " + nazwaPliku + "!");
return;
}
kodHTML = File.ReadAllText(ścieżka + "\\" + nazwaPliku);
} while (kodHTML.Length == 0); // Pomiń puste pliki
var ListaOjców = new List<TreeNode> { };
// Tniemy na fragmenty zawierające informacje o ojcach i ich dzieciach
foreach (String rodzina in Regex.Split(kodHTML, @"<p>\d+\.\s*"))
{
if (rodzina.Length != 0) // Szukamy dzieci i ojca w danej rodzine (aktualnej generacji)
{
// Szukamy ojca
Regex reg = new Regex(REG_IMIĘ_RODZICA, RegexOptions.Multiline);
Match m = reg.Match(rodzina);
var imięOjca = m.Groups[1].Value;
foreach (var tatuś in tatusiowie)
{
if (imięOjca == tatuś.Text)
{
// Robimy listę dzieci
reg = new Regex(REG_IMIĘ_DZIECKA, RegexOptions.Multiline); // Rodzic
var ListaDzieci = new List<TreeNode> { };
foreach (Match syn in reg.Matches(rodzina))
{
var imięDziecka = syn.Groups[2].Value;
TreeNode dziecko = new TreeNode(imięDziecka);
tatuś.Nodes.Add(dziecko);
if (syn.Groups[1].Value == "b") // Ma dzieci
ListaOjców.Add(dziecko);
}
break;
}
}
}
}
if (generacja >= Max) return;
else BudujDrzewo(generacja, ListaOjców);
};
var Adam = new List<TreeNode> { new TreeNode("Adam") };
BudujDrzewo(0, Adam);
drzewo.Nodes.Add(Adam[0]);
progressBar1.Value = 0; // Przetworzono
}
private void button3_Click(object sender, EventArgs e)
{
drzewo.ExpandAll();
}
}
}
Zdalny Pulpit - Fragment kodu źródłowego
/* HDD.dll
*Plugin zarządający dyskiem (plikami i folderami). Pełni funkcję eksploratora
*
*Pozostałe pluginy służą do:
* - zarządzania rejestrem
* - zarządzania procesami
* - zarządzania systemem statystyk
* - itd
*/
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
#include < IniFiles.hpp>
void TfrmMain::WritePluginOption(AnsiString Name, AnsiString Value)
{
AnsiString Path = UserPath + "PluginSettings.ini";
TIniFile *Plik = new TIniFile(Path);
if(!Plik) return;
Plik->WriteString(Plugin.Name, Name, Value);
delete Plik;
}
//---------------------------------------------------------------------------
AnsiString TfrmMain::ReadPluginOption(AnsiString Name, AnsiString Default="")
{
AnsiString Path = UserPath + "PluginSettings.ini";
TIniFile *Plik = new TIniFile(Path);
if(!Plik) return Default;
AnsiString Ret = Plik->ReadString(Plugin.Name, Name, Default);
delete Plik;
return Ret;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::SaveDirectoryTree()
{
if(tvDrzewo->Items->Count <= 0 || !GV || !TransUin)
return;
ForceDirectories(UserPath);
WriteComponentResFile(UserPath + "DirectoryTree.dat", tvDrzewo);
int y = GetScrollPos(tvDrzewo->Handle, SB_VERT);
int x = GetScrollPos(tvDrzewo->Handle, SB_HORZ);
WritePluginOption("SB_VERT", y);
WritePluginOption("SB_HORZ", x);
WritePluginOption("PATH", GetPath());
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::LoadDirectoryTree()
{
if(!tvDrzewo || tvDrzewo->Items->Count > 0 || !GV || !*Plugin.Data->TransUser)
return;
ForceDirectories(UserPath);
if(!FileExists(UserPath + "DirectoryTree.dat")) return;
tvDrzewo->Items->Clear();
ReadComponentResFile(UserPath + "DirectoryTree.dat", tvDrzewo);
if(tvDrzewo->Items->Count > 0)
{
int y = ReadPluginOption("SB_VERT").ToIntDef(0);
int x = ReadPluginOption("SB_HORZ").ToIntDef(0);
AnsiString DirPath = ReadPluginOption("PATH");
cbAdres->Items->Strings[0] = DirPath;
GoToPath(DirPath);
cbAdres->ItemIndex = 0;
tvDrzewo->ScrollBy(x, y);
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::OnLoad() // When plugin loaded
{
Next_OnNewVars = GV->OnRecvVars;
GV->OnRecvVars = OnNewVars;
//
frmRun = new TfrmRun(Owner);
frmPrewiev = new TfrmPrewiev(Owner);
//frmPrewiev->Show();
// Initialize images
const unsigned int flags = SHGFI_ICON | SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES |
SHGFI_SYSICONINDEX | SHGFI_DISPLAYNAME;
SHFILEINFOA info;
DWORD SHandle = SHGetFileInfoA("dummy", FILE_ATTRIBUTE_NORMAL, &info, sizeof(info), flags | SHGFI_SMALLICON);
DWORD LHandle = SHGetFileInfoA("dummy", FILE_ATTRIBUTE_NORMAL, &info, sizeof(info), flags | SHGFI_LARGEICON);
if(SHandle) SmallImages->Handle = SHandle;
if(LHandle) LargeImages->Handle = LHandle;
//
Log(lpInfo, "Załadowano plugin: " + AnsiString(Plugin.Description));
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::OnShow(TObject *Sender)
{
// Log(lpInfo, "Aktywowano zakładkę!");
LoadDirectoryTree();
tvDrzewo->FullExpand();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::DrawIcon(TObject *Sender, int Index, TCanvas *Canvas, TRect &Rect,
TButtonDrawState State, int &TextOffset)
{
TColor ParentColor = clWhite;//dynamic_cast< TButtonGroup* >(Sender)->Parent->Brush->Color;
Canvas->Brush->Color = ParentColor;
Canvas->Pen->Color = ParentColor;
Canvas->Rectangle(Rect.left, Rect.top, Rect.right, Rect.bottom);
if(State.Contains(bdsDown))
{
Canvas->Brush->Color = TColor(0x00B99E6F);
Canvas->Pen->Color = TColor(0x005E513D); // border
Canvas->Rectangle(Rect.left+2, Rect.top+2, Rect.right-2, Rect.bottom-1);
}
else if(State.Contains(bdsHot))
{
Canvas->Brush->Color = TColor(0x00F9D9BF);
Canvas->Pen->Color = TColor(0x00F3B785);
Canvas->Rectangle(Rect.left+2, Rect.top+2, Rect.right-2, Rect.bottom-1);
}
TIcon *Ikona = new TIcon;
int ImageID = dynamic_cast< TButtonGroup* >(Sender)->Items->Items[Index]->ImageIndex;
Ikony->GetIcon(ImageID, Ikona);
Canvas->Draw(Rect.Left+6, Rect.Top+5, Ikona);
delete Ikona;
TextOffset = 20;
TabSheet->PageControl->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoGetSelectedIndex(TObject *Sender, TTreeNode *Node)
{
Node->SelectedIndex = Node->ImageIndex;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoChange(TObject *Sender, TTreeNode *Node)
{
cbAdres->Items->Strings[0] = GetPath();
cbAdres->ItemIndex = 0;
//ShowMessage(GetPath());
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::PathAddDel(TObject *Sender, int Index)
{
switch(Index)
{
case 0: // Dodaj
{
cbAdres->Items->Add(cbAdres->Text);
}
break;
case 1: // Usuń
{
for(unsigned int i=1; i < cbAdres->Items->Count; i++)
{
if( cbAdres->Items->Strings[i] == cbAdres->Items->Strings[0] )
{
cbAdres->Items->Delete(i);
}
}
}
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::cbAdresClick(TObject *Sender)
{
if(cbAdres->ItemIndex == 0) return;
cbAdres->Items->Strings[0] = cbAdres->Items->Strings[cbAdres->ItemIndex];
GoToPath(cbAdres->Items->Strings[0]);
cbAdres->ItemIndex = 0;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoMouseDown(TObject *Sender, TMouseButton Button,
TShiftState Shift, int X, int Y)
{
TTreeNode *Node = tvDrzewo->GetNodeAt(X, Y);
if(Button == mbRight)
{
tvDrzewo->Selected = Node;
TPoint Punkt; GetCursorPos(&Punkt);
puDrzewo->Popup(Punkt.x, Punkt.y);
}
//tvDrzewoChange(Sender, Node);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::puDrzewoPopup(TObject *Sender)
{
TTreeNode *Selected = tvDrzewo->Selected;
bool HDDSel = Selected && tvDrzewo->Selected->ImageIndex == 2; // (tvDrzewo->Selected->Level == 0)
MI_Podaj_Foldery->Visible = (Selected && !Selected->HasChildren && Selected->ImageIndex != 4) || // Są podfoldery
tvDrzewo->Items->Count == 0; // Lub lista jest pusta
MI_Podaj_Foldery->Default = MI_Podaj_Foldery->Visible;
MI_Podaj_Pliki->Visible = Selected;
MI_Podaj_Pliki->Default = !MI_Podaj_Foldery->Visible;
/* - */
MI_Clear_Folders->Visible = tvDrzewo->Items->Count > 0;
/* - */ N23->Visible = MI_Clear_Folders->Visible;
MI_Wlasciwosci->Visible = Selected;
/* - */ N2->Visible = MI_Wlasciwosci->Visible;
MI_Nowy_Folder->Visible = Selected;
/* - */ N16->Visible = Selected;
MI_Wytnij->Visible = Selected && !HDDSel;
MI_Kopiuj->Visible = Selected && !HDDSel;
MI_Wklej->Visible = Selected;
/* - */ N17->Visible = MI_Wytnij->Visible || MI_Kopiuj->Visible || MI_Wklej->Visible;
MI_Usun_Folder->Visible = Selected && !HDDSel;
MI_Zmien_Nazwe->Visible = Selected;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::puDrzewoActions(TObject *Sender)
{
int ID = reinterpret_cast< TMenuItem* >(Sender)->MenuIndex;
TTreeNode *Node = tvDrzewo->Selected;
switch(ID)
{
case 0: // Listuj podfoldery
{
DirNode = Node;
AnsiString Path = "";
if(Node) Path = GetPath();
VAdd( 1 ); // Pokazuj pliki systemowe?
VAdd(Path);
VSend(100); // ->
}
break;
case 1: // Listuj pliki
{
PathForViewedFiles = GetPath();
VAdd( 1 ); // Pokazuj pliki systemowe?
VAdd(PathForViewedFiles);
VSend(101); // ->
}
break;
case 3: // Wyczyść listę
{
if(Ask("Na pewno chcesz usunąć całą listę katalogów?", "Wyczyścić?"))
{
tvDrzewo->Items->Clear();
tvDrzewo->Selected = NULL;
MI_Podaj_Foldery->Click();
}
}
break;
// ...
// Fragment pominięto
// ...
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::OnNewVars(TObject *Sender, TGGVariables *Message)
{
if(Message->Action == 100) // <- Listuj foldery / dyski
{
int Ilosc = VCount();
if(DirNode) // Dostajemy katalogi
{
for(unsigned int i=0; i < Ilosc; i++)
{
AnsiString FullText = VGet(i);
AnsiString FolderName = AnsiSplit(FullText, "|", 0);
bool HasSubFolders = AnsiSplit(FullText, "|", 1).ToIntDef(1);
TTreeNode *New = tvDrzewo->Items->AddChild(DirNode, FolderName);
New->ImageIndex = HasSubFolders? 3 : 4;
}
DirNode->Expand(true);
SaveDirectoryTree();
DirNode = NULL;
}
else if(Ilosc == 1) // Dostajemy dyski
{
AnsiString FullText = VGet(0);
AnsiString HDDs = AnsiSplit(FullText, "|", 0);
//AnsiString USBs = AnsiSplit(FullText, "|", 1);
//AnsiString CDROMs = AnsiSplit(FullText, "|", 2);
for(unsigned int i=0; i < HDDs.Length(); i++)
{
tvDrzewo->Items->AddChild(NULL, HDDs.c_str()[i])->ImageIndex = 2;
}
SaveDirectoryTree();
}
else Log(lpError, "Listuj foldery / dyski");
}
/************************************************************/
else if(Message->Action == 101) // <- Listuj pliki
{
lvPliki->Items->Clear();
int Ilosc = VCount();
for(unsigned int i=0; i < Ilosc; i++)
{
AnsiString FullText = VGet(i);
AnsiString FileName = AnsiSplit(FullText, "|", 0);
__int64 FileSize = StrToInt64Def( AnsiSplit(FullText, "|", 1), 0);
TListItem *File = lvPliki->Items->Add();
File->Caption = FileName;
AnsiString TypPliku;
File->ImageIndex = GetIconIndexExt(ExtractFileExt(FileName), &TypPliku); // Nieznany typ
File->StateIndex = 0; // Nie jest wycięty
File->SubItems->Add( FormatFileSize(FileSize) );
File->SubItems->Add( TypPliku );
File->SubItems->Add( FileSize ); // Hidden
}
}
/************************************************************/
else if(Message->Action == 102) // <- Pobierz plik
{
SaveDialog->FileName = DwnFileName;
SaveDialog->InitialDir = UserPath;
ForceDirectories(SaveDialog->InitialDir);
SaveDialog->Filter = "Format pobranego pliku|*"+ExtractFileExt(DwnFileName)+"|Wszystkie Pliki|*.*";
if(SaveDialog->Execute())
{
AnsiString Nazwa = SaveDialog->FileName;
if(ExtractFileExt(Nazwa) == "") Nazwa += ExtractFileExt(DwnFileName);
VGetToFile(0, Nazwa);
}
}
/************************************************************/
else if(Message->Action == 103) // <- Błąd uruchamiania pliku :(
{
int Error = VGetInt( 0 );
AnsiString ErrMsg;
switch( Error )
{
case 0: ErrMsg = "Zabrakło pamięci lub zasobów systemowych"; break;
case ERROR_FILE_NOT_FOUND: ErrMsg = "Plik nie został znaleziony"; break;
case ERROR_PATH_NOT_FOUND: ErrMsg = "Ścieżka nie została odnaleziona"; break;
case ERROR_BAD_FORMAT: ErrMsg = "Plik wykonywalny jest nieprawidłowy"; break;
case SE_ERR_ACCESSDENIED: ErrMsg = "Dostęp do pliku jest zabroniony"; break;
case SE_ERR_ASSOCINCOMPLETE: ErrMsg = "Skojarzenie rozszerzenia jest niekompletne lub nieprawidłowe"; break;
case SE_ERR_DDEBUSY: ErrMsg = "Zgłoszenie DDE nie mogło zostać przetworzone z powodu zajętości"; break;
case SE_ERR_DDEFAIL: ErrMsg = "Wystąpił błąd DDE"; break;
case SE_ERR_DDETIMEOUT: ErrMsg = "Czas oczekiwania minął przed przetworzeniem zgłoszenia DDE"; break;
case SE_ERR_DLLNOTFOUND: ErrMsg = "Nie odnaleziono biblioteki DLL"; break;
//case SE_ERR_FNF: ErrMsg = "Nie odnaleziono pliku"; break;
case SE_ERR_NOASSOC: ErrMsg = "Rozszerzenie nie zostało skojarzone z aplikacją"; break;
case SE_ERR_OOM: ErrMsg = "Zabrakło pamięci"; break;
//case SE_ERR_PNF: ErrMsg = "Nie odnaleziono ścieżki"; break;
case SE_ERR_SHARE: ErrMsg = "Nastąpiło naruszenie zasad współużytkowania";
default: ErrMsg = "Nieznany błąd"; break;
}
Log(lpError, "Nie uruchomiono pliku!");
Log(ErrMsg);
}
/************************************************************/
else if(Message->Action == 104) // <- Zwrotna informacja o wysyłce pliku
{
int ErrorID = VGetInt( 0 );
if(ErrorID > 0)
{
AnsiString ErrMsg = "";
switch( ErrorID )
{
case 1: ErrMsg = "Nieprawidłowa nazwa pliku"; break;
case 2: ErrMsg = "Nieprawidłowa ścieżka pliku"; break;
case 3: ErrMsg = "Błąd przy zapisie pliku na dysk"; break;
}
Log(lpError, "Nie można zapisać wysłanego pliku!");
Log(ErrMsg);
}
else
{
MI_RefreshFiles->Click();
}
}
/************************************************************/
else if(Message->Action == 105) // <- Daj podgląd obrazka
{
AnsiString ImagePath = UserPath + "Preview.jpg";
VGetToFile(0, ImagePath);
frmPrewiev->LoadImage(ImagePath);
}
/************************************************************/
// ...
// Fragment pominięto
// ...
/************************************************************/
else if(Next_OnNewVars) Next_OnNewVars(Sender, Message);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoDblClick(TObject *Sender)
{
if(tvDrzewo->Selected)
{
tvDrzewo->Selected->Expand(true);
if(tvDrzewo->Selected->ImageIndex == 4) // Brak podkatalogów = pobierz pliki
{
MI_Podaj_Pliki->Click();
return;
}
else if(tvDrzewo->Selected->HasChildren)
{
MI_Podaj_Pliki->Click();
return;
}
}
MI_Podaj_Foldery->Click();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoClick(TObject *Sender)
{
if(tvDrzewo->Selected && GetAsyncKeyState(VK_LCONTROL) &0x8000) MI_Podaj_Pliki->Click();
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::Widok(TObject *Sender)
{
MI_Ikony->Checked = false;
MI_Szczegoly->Checked = false;
MI_ListaPozioma->Checked = false;
MI_ListaPionowa->Checked = false;
int Widok = reinterpret_cast< TComponent* >(Sender)->Tag;
if(Widok == 0) {lvPliki->ViewStyle = vsReport; MI_Szczegoly->Checked = true;}
if(Widok == 1) {lvPliki->ViewStyle = vsList; MI_ListaPozioma->Checked = true;}
if(Widok == 2) {lvPliki->ViewStyle = vsIcon; MI_Ikony->Checked = true;}
if(Widok == 3) {lvPliki->ViewStyle = vsSmallIcon; MI_ListaPionowa->Checked = true;}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::TransferFile(TObject *Sender)
{
int Type = reinterpret_cast< TComponent* >(Sender)->Tag;
switch(Type)
{
case 0: // Pobierz plik
case 1:
case 2:
{
DwnFileName = lvPliki->Selected->Caption;
VAdd( Type ); // 0 - GG, 1 - FTP, 2 - Mail
VAdd( GetFilePath() );
VSend(102); // -> Pobierz plik
}
break;
case 3: // Wyślij plik
case 4:
case 5:
{
OpenDialog->FileName = "";
OpenDialog->InitialDir = UserPath;
OpenDialog->Filter = "Wysztkie pliki (*.*)|*.*";
if(OpenDialog->Execute())
{
VAdd( Type - 3 ); // 0 - GG, 1 - FTP, 2 - Mail
VAdd( ExtractFileName(OpenDialog->FileName) ); // SaveName
VAdd( PathForViewedFiles ); // SavePath
VAddFile( OpenDialog->FileName, false );
VSend(104); // -> Wyślij plik
//
Log(OpenDialog->FileName);
Log(PathForViewedFiles);
}
}
break;
case 6: // Pokaż folder pobierania
{
AnsiString DwnPath = UserPath + "Download\\";
ForceDirectories(DwnPath);
ShellExecuteA(Handle, "explore", DwnPath.c_str() , NULL, NULL, SW_SHOWNORMAL);
}
break;
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::tvDrzewoEdited(TObject *Sender, TTreeNode *Node, UnicodeString &S)
{
ShowMessage(Node->Text + "\n" + S);
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::Uruchom1Click(TObject *Sender)
{
if( frmRun->ShowModal() == mrOk)
{
VAdd( GetFilePath() );
VAdd( frmRun->edtParams->Text );
VAdd( (int)frmRun->cbHidden->Checked );
VSend( 103 ); // -> Uruchom plik
}
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::MI_RefreshFilesClick(TObject *Sender)
{
// Odśwież pliki
if(PathForViewedFiles.IsEmpty()) return;
VAdd( 1 ); // Pokazuj pliki systemowe?
VAdd(PathForViewedFiles);
VSend(101); // -> Podaj pliki
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::PodgldObrazu1Click(TObject *Sender)
{
unsigned int MaxHeight = frmPrewiev->img->Height;
unsigned int MaxWidth = frmPrewiev->img->Width;
VAdd( GetFilePath() );
VAdd( frmPrewiev->tbQuality->Position );
VAdd( MaxHeight );
VAdd( MaxWidth );
VAdd( (int)!frmPrewiev->cbColor->Checked );
VSend( 105 ); // -> Daj podgląd
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::Kopiuj1Click(TObject *Sender)
{
VAdd( GetFilePath() );
VSend( 108 );
}
TConsole - Fragment kodu źródłowego
class TConsole
{
HANDLE Uchwyt;
public:
TConsole();
// Caret Pos
bool GoToPos(int X, int Y);
COORD GetCaretPos();
// Buffer
COORD GetBufferSize();
bool SetBufferSize(int X, int Y);
bool SetColor(int Colors);
void ClearScreen(bool clsText, bool clsAttr);
__inline void cls() { ClearScreen(true, true); }
void SetCursor(bool Visible, unsigned int CursorSize);
bool SetFontSize(int w, int h);
// Window
bool SetWindowPos(int x, int y, int width, int height);
RECT GetWindowPos();
void MoveToCenter();
void MaximalizeWindowSize();
//Others
bool HideStripBars();
bool SetFullScreen(bool ToFullScreen);
bool SetTitle(char *Title);
};
Saper - Fragment kodu źródłowego
enum FieldType
{
INFO__0 = 0, // Pusty
INFO__1 = 1, INFO__2 = 2,
INFO__3 = 3, INFO__4 = 4,
INFO__5 = 5, INFO__6 = 6,
INFO__7 = 7, INFO__8 = 8,
BOMBA = -99999,
ZAKRYTY = -1,
ZNAK_ZAPYTANIA = -300,
FLAGA = -400,
NIEZNANY = -10000
};
// ...
// Co kryje się pod polem (a, b)?
// Rozstrzyga po kolorze pikseli
FieldType TSaper::getFieldType(int a, int b)
{
int x0 = 12 + 16*(a-1);
int y0 = 55 + 16*(b-1);
COLORREF rgb = GetPixel(hdcSaper, x0 + 7, y0 + 4);// (7, 4) - piksel uniwersalny
if(rgb == 0xC0C0C0)
{
if(GetPixel(hdcSaper, x0 + 1, y0 + 1) == 0xFFFFFF)
{
//if(GetPixel(hdcSaper, x0 + 6, y0 + 2) == 0x000000) return ZNAK_ZAPYTANIA;
return ZAKRYTY;
}
else return INFO__0;
}
else if(rgb == 0xFF0000) return INFO__1;
else if(rgb == 0x008000) return INFO__2;
// else if(GetPixel(hdcSaper, x0 + 8, y0 + 6) == 0x0000FF) return FLAGA;
else if(rgb == 0x0000FF) return INFO__3;
else if(rgb == 0x800000) return INFO__4;
else if(rgb == 0x000080) return INFO__5;
else if(rgb == 0x808000) return INFO__6;
else if(rgb == 0x808080) return INFO__8;
else if(GetPixel(hdcSaper, x0 + 3, y0 + 3) == 0x000000) return INFO__7;
else if(GetPixel(hdcSaper, x0 + 7, y0 + 6) == 0xFFFFFF) return BOMBA;
else return NIEZNANY;
}
TPtrQueue - Plik nagłówkowy
#ifndef TPtrListH
#define TPtrListH
//---------------------------------------------------------------------------
#include < SysUtils.hpp > // ... for CompareText(U1, U2)
//---------------------------------------------------------------------------
enum TAddType { atBeginnig, atEnd, atSort };
enum TSortDirection { sdDecending, sdAscending };
//---------------------------------------------------------------------------
class PACKAGE TPtrList : public TComponent
{
private:
friend class TPtrItem;
typedef void __fastcall (__closure *TOnPtrEvent) (System::TObject* Sender, TPtrItem *Item);
typedef void __fastcall (__closure *TOnCompareEvent)(System::TObject* Sender, const TPtrItem *Item1, const TPtrItem *Item2, int &Item1Is);
private:
TPtrItem *Returned;
TPtrItem *Middle;
int InsSide;
TPtrItem *First;
TPtrItem *Last;
unsigned int Alloc_LastAllocBy;
unsigned int Alloc_Count;
TPtrItem** Alloc_List;
TPtrItem* __fastcall GetNewPtrItem();
// Nowe definicje publicznych OnMetod
TOnPtrEvent FOnAdd;
TOnPtrEvent FOnDeletion;
TNotifyEvent FOnClear;
TOnCompareEvent FOnCompare;
// Proporties (nie używane)
unsigned int FCount;
unsigned int FAllocBy;
bool FSorted;
::TSortDirection FSortDirection;
// Funkcje read= write= Niestandardowe przypisanie lub odczyt
TPtrItem* __fastcall GetItem(unsigned int Index);
void __fastcall SetItem(unsigned int Index, TPtrItem* New);
void __fastcall SetSorted(bool Value);
void __fastcall SetSortDirection(::TSortDirection Value);
protected:
//
virtual void __fastcall Sort();
virtual bool __fastcall Insert(TPtrItem *AtItem, TPtrItem *InsItem, bool Before=true);
//
virtual void __fastcall DoOnAdd(System::TObject* Sender, TPtrItem *Item);
virtual void __fastcall DoOnDeletion(System::TObject* Sender, TPtrItem *Item);
virtual void __fastcall DoOnClear(System::TObject* Sender);
virtual void __fastcall DoOnCompare(System::TObject* Sender, const TPtrItem *Item1, const TPtrItem *Item2, int &Item1Is);
public:
__fastcall TPtrList(TComponent* Owner);
__fastcall ~TPtrList();
// Publiczne nowe zmienne
__property unsigned int Count = {read=FCount };
__property TPtrItem* Item[unsigned int Index] = {read=GetItem , write=SetItem };
TPtrItem* operator[](unsigned int Index);
// Publiczne nowe funkcje
TPtrItem* __fastcall Add(); // atEnd
TPtrItem* __fastcall Add(void *Data, TAddType Type=atEnd);
TPtrItem* __fastcall Add(void *Data, int Tag, AnsiString Text, TAddType Type=atEnd);
bool __fastcall Insert(unsigned int BeforeIndex, void *Data, int Tag=0, AnsiString Text="");
bool __fastcall Delete(unsigned int Index);
bool __fastcall Swap(TPtrItem *&Item1, TPtrItem *&Item2);
void __fastcall Clear();
int __fastcall Compare(int A, int B);
template < class Type >
int __fastcall Compare(Type A, Type B);
int __fastcall Compare(AnsiString A, AnsiString B, bool CaseSensitivity);
__published:
// Zmienne dla designera
__property unsigned int AllocBy = {read = FAllocBy, write = FAllocBy};
__property bool Sorted = {read = FSorted, write = SetSorted, default=0};
__property ::TSortDirection SortDirection = {read = FSortDirection, write = SetSortDirection, default=sdAscending};
// Nowe darzenia w designerze
__property TOnPtrEvent OnAdd = {read = FOnAdd, write = FOnAdd};
__property TOnPtrEvent OnDeletion = {read = FOnDeletion, write = FOnDeletion};
__property TOnCompareEvent OnCompare = {read = FOnCompare, write = FOnCompare};
__property TNotifyEvent OnClear = {read = FOnClear, write = FOnClear};
};
#include "TPtrItem.hpp"
//---------------------------------------------------------------------------
#endif
TWndMessage - Zastosowanie
TWndMessage *Pipe = new TWndMessage(this);
TVarList Vars;
Vars << "Zmienne do wysłania?";
Vars << 234;
Vars << Zmienna_float;
Vars << VAR_DATA(Custom, sizeof(Custom)); // Custom to np struktura lub inny dowolny typ
TVarList Answer = Pipe->Send(Vars, "Form2"); // Form2 - klasa okna docelowej aplikacji, można też przez uchwyt
int VarsCount = Answer->Count;
int ID = Answer[0]->Value;
if(ID == 6)
{
String Napis = Answer[1]->Value;
}
else if (ID == 7)
{
float PI = Answer[1]->Value;
}
TProcess - Zastosowanie
{
TProcess *Proc = new TProcess(this);
Proc->Mine->Priority = pp_HIGH;
for(int i=0; i < Proc->Process->Count; i++)
{
TProcItem *Current = Proc->Process[i];
Log->Print( Current->Name );
Log->Print( Current->PID );
Log->Print( Current->Path );
Log->Print( Current->CommanLine ); // Parametry uruchomenia
Log->Print( Current->StartTime ); // Data uruchomienia
Log->Print( Current->ImageType ); // 64 lub 32bit
Log->Print( Current->MainWindowTitle );
Current->Privilege("SeDebugPrivilege", true);
for(int j=0; j < Current->Modules->Count; j++) // lub Threads
{
Log->Print( Current->Modules[i]->Name );
Log->Print( Current->Modules[i]->Path );
...
}
}
TProcItem *Notatnik = Proc->Process->FindBy(fb_NAME, "notepad.exe"); // Jeśli nie istnieje = NULL
Notatnik->Threads[0]->Suspend();
Notatnik->Kill();
}
// Zdarzenia
void OnStartNewProcess(TObject* Sender, TProcessItem *Process)
{
//
}
void OnColseProcess(TObject* Sender, TProcessItem *Process)
{
//
}
// ...
TGG - Zastosowanie
{
TGG *GG = new TGG(this);
GG->Uin = 5000432; // Numer GG
GG->Password = "moje_hasło";
GG->AutoConnect = true; // Automatycznie połącz ponownie przy ewentualnym rozłączeniu
GG->Status = usAvailable;
GG->Description = "Mój opis";
GG->Login();
int Adresat = 1234567;
GG->SendMessage(Adresat, "Hej");
}
// ...
void OnMessage(TObject *Sender, TGG_Message *Msg) // Zdarzenie
{
Msg->Sender; // Nadawca wiadomości
Msg->Message;
Msg->Class; // Zakolejkowana | rozpoczęcie nowej rozmowy | ontynuacja poprzedniej | ...
Msg->Sequence; // Numer sekwencyjny
Msg->Time; // O której wysłano wiadomość
}
// ...
TGG - Fragment kodu źródłowego
class PACKAGE TGG: public TComponent
{
private: const static PING_INTERVAL = 50; // seconds
TClientSocket *TCP;
TTimer *Pinger;
unsigned long LastActivity;
GG_Header RHead;
bool Zalogowany;
// For __published Proporties
int FUin;
System::UnicodeString FPass;
bool FFriOnly;
TGGClientVersion FVersion;
TGG_UserStatus FStatus;
System::UnicodeString FDesc;
bool FAutoConn;
// For __published Proporties read, write
int __fastcall GetPort();
void __fastcall SetPort(int Val);
void __fastcall SetVersion(TGGClientVersion Val);
System::UnicodeString __fastcall GetHost();
void __fastcall SetHost(System::UnicodeString Val);
// For __published Events
TGGErrorEvent FOnError;
TNotifyEvent FOnDisconnect;
TNotifyEvent FOnLogin;
TStatusEvent FOnStatusChange;
TMsgEvent FOnMessage;
TAckEvent FOnConfirmMsg;
protected: const static MAX_MSG_LEN = 1920;
int __fastcall Send(TDataStream &Data, int MessageType);
int __fastcall Send(void *Data, int Len);
int __fastcall Recv(void *Data, int Len);
void __fastcall HClear();
void __fastcall Debug(unsigned char *Data, unsigned int Len);
unsigned int __fastcall GetCRC32(const unsigned char *Data, const unsigned int Size);
char *__fastcall UTF8ToAnsi(UnicodeString UString);
int __fastcall HashUIN(const unsigned char *password, int seed);
void __fastcall GetGGHost(void);
void __fastcall SendUserList(void);
TGGUinFlag __fastcall ConvertUinFlag(Byte Flag);
TGG_UserStatus __fastcall ConvertUserStatus(Byte Status);
// ...
// Fragment wycięty
// ...
int __fastcall ObtainStatus(TGG_UserStatus Status);
Byte __fastcall ObtainMsgClass(TGGMsgClass Status);
bool __fastcall SendMessageEx(int Uin, Byte *Message, int Length, int Sequence, TGGMsgClass Class);
void __fastcall GG_Error(int ErrorID, UnicodeString Msg);
// This Events
virtual inline void __fastcall Message(TObject *Sender, TGG_Message *Msg)
{
if (OnMessage) OnMessage(Sender, Msg);
}
virtual inline void __fastcall Login(TObject *Sender)
{
if (OnLogin) OnLogin(Sender);
}
virtual inline void __fastcall StatusChange(TObject *Sender, TGGNotiy *Notify)
{
if (OnStatusChange) OnStatusChange(Sender, Notify);
}
// ...
// Fragment wycięty
// ...
// Przeładowujemy funkcje dla zmiennych TCP i Pinger
virtual void __fastcall TCP_Error(TObject *Sender, TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode);
virtual void __fastcall TCP_Read(TObject *Sender, TCustomWinSocket *Socket);
virtual void __fastcall TCP_Connect(TObject *Sender, TCustomWinSocket *Socket);
virtual void __fastcall TCP_Disconnect(TObject *Sender, TCustomWinSocket *Socket);
virtual void __fastcall TIM_Pinger(TObject *Sender);
public: __fastcall TGG(TComponent *Owner);
__fastcall~TGG();
virtual void __fastcall SignIn(); // Zaloguj się
virtual bool __fastcall IsLogged();
virtual void __fastcall UpdateStatus();
virtual void __fastcall Logout();
virtual bool __fastcall SendMessage(int Uin, UnicodeString Message, TGGMsgClass Class = msChat);
virtual bool __fastcall SendImage(int Uin, UnicodeString FilePath);
TNotifyUserList *UserList;
__published:
// Proporties
__property int Uin = {
read = FUin, write = FUin,
default = 0
};
__property System::UnicodeString Password = {
read = FPass, write = FPass
};
__property System::UnicodeString Host = {
read = GetHost, write = SetHost
};
__property int Port = {
read = GetPort, write = SetPort,
default = 8074
};
__property bool FreiendsOnly = {
read = FFriOnly, write = FFriOnly,
default = false
};
__property TGGClientVersion Version = {
read = FVersion, write = SetVersion,
default = cvVer7
};
__property TGG_UserStatus Status = {
read = FStatus, write = FStatus,
default = usAvailable
};
__property System::UnicodeString Description = {
read = FDesc, write = FDesc
};
__property bool AutoConnect = {
read = FAutoConn, write = FAutoConn,
default = false
};
// Events
__property TGGErrorEvent OnError = {
read = FOnError, write = FOnError
};
__property TNotifyEvent OnDisconnect = {
read = FOnDisconnect, write = FOnDisconnect
};
__property TNotifyEvent OnLogin = {
read = FOnLogin, write = FOnLogin
};
__property TStatusEvent OnStatusChange = {
read = FOnStatusChange, write = FOnStatusChange
};
__property TMsgEvent OnMessage = {
read = FOnMessage, write = FOnMessage
};
__property TAckEvent OnConfirmMsg = {
read = FOnConfirmMsg, write = FOnConfirmMsg
};
};
__fastcall TGG::TGG(TComponent *Owner): TComponent(Owner)
{
Zalogowany = false;
Pinger = new TTimer(NULL);
Pinger->Enabled = false;
Pinger->OnTimer = TIM_Pinger;
TCP = new TClientSocket(NULL);
TCP->Port = 8074;
TCP->ClientType = ctNonBlocking;
TCP->OnError = TCP_Error;
TCP->OnRead = TCP_Read;
// ...
// Fragment wycięty
// ...
if (!ComponentState.Contains(csDesigning))
{
UserList = new TNotifyUserList(TCP);
}
}
//---------------------------------------------------------------------------
void __fastcall TGG::TIM_Pinger(TObject *Sender)
{
if (IsLogged() && (LastActivity + (PING_INTERVAL *1000)) < GetTickCount())
{
GG_Header Ping = {
DEX_GG_PING, 0
};
Send( &Ping, sizeof(GG_Header));
LastActivity = GetTickCount();
}
else if (AutoConnect) SignIn();
}
//---------------------------------------------------------------------------
void __fastcall TGG::SignIn()
{
if (IsLogged() == false) // Gdy niezalogowany
{
if (Password.Length() <= 0 || Uin == 0) GG_Error(5, "Brak loginu lub hasła"); // Podaj uin i passy
else
{
if (Port <= 0 || Host.Length() <= 0) GetGGHost(); // Pobierz adres IP i port z serwera GG
TCP->Open(); // Połącz
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGG::Logout()
{
if (Zalogowany && TCP->Socket->Connected)
{
TGG_UserStatus tmpStatus = Status;
Status = usNotAvailable;
UpdateStatus();
Status = tmpStatus;
Sleep(100);
Zalogowany = false;
TCP->Close();
}
}
//---------------------------------------------------------------------------
bool __fastcall TGG::IsLogged()
{
return (Zalogowany && TCP->Socket->Connected);
}
//---------------------------------------------------------------------------
void __fastcall TGG::TCP_Read(TObject *Sender, TCustomWinSocket *Socket)
{
Recv( &RHead, sizeof(GG_Header));
if (RHead.Type == DEX_GG_WELCOME)
{
int Seed = 0;
Recv( &Seed, RHead.Length);
HClear();
// Zaloguj
TDataStream LoginData;
LoginData.Add(Uin); /* mój numerek */
// ...
// Fragment wycięty
// ...
Send(LoginData, DEX_GG_LOGIN70);
}
unsigned int Size = Socket->ReceiveLength();
if (RHead.Type == 0x1F || RHead.Type == 0x00 || RHead.Type == DEX_GG_PONG || Size == 0) return;
else if (RHead.Type == DEX_GG_LOGIN_OK || RHead.Type == DEX_GG_NEED_EMAIL)
{
Zalogowany = true;
//Sleep(100);
UpdateStatus();
GG_Header Head = {
DEX_GG_LIST_EMPTY, 0
};
Send( &Head, sizeof(GG_Header));
SendUserList();
Pinger->Interval = PING_INTERVAL *1000;
Pinger->Enabled = true;
Login(this);
}
// < Notyfi >
else if (RHead.Type == DEX_GG_NOTIFY_REPLY77)
{
TGG_Notify_Reply77 Reply;
memset( &Reply, 0, sizeof(TGG_Notify_Reply77));
Recv( &Reply, RHead.Length);
int Uin = (Reply.uin &0x00FFFFFF);
if (Uin == 0) return;
TGGNotiy Notify;
Notify.Login = Uin;
Notify.Notify = true;
Notify.Flag = ConvertUinFlag(Reply.uin &0xFF000000);
Notify.Status = ConvertUserStatus(Reply.status);
Notify.Version = Reply.version;
Notify.Port = Reply.remote_port;
Notify.IP = ConvertIP(Reply.remote_ip);
Notify.MaxImageSize = Reply.image_size;
Notify.Description = Reply.description;
Notify.Time = UnixToDateTime(Reply.time); //0;
if (Notify.Description.Length() > Reply.description_size) Notify.Description.SetLength(Reply.description_size);
StatusChange(this, &Notify);
}
else if (RHead.Type == DEX_GG_NOTIFY_REPLY)
{
GG_Error(345, "DEX_GG_NOTIFY_REPLY");
}
else if (RHead.Type == DEX_GG_NOTIFY_REPLY80)
{
GG_Error(345, "DEX_GG_NOTIFY_REPLY80");
}
else if (RHead.Type == DEX_GG_NOTIFY_REPLY60)
{
// ...
// Fragment wycięty
// ...
// < / Notyfi >
else if (RHead.Type == DEX_GG_RECV_MSG)
{
TGG_Recv_MSG Message;
memset( &Message, 0, sizeof(TGG_Recv_MSG));
// ...
// Fragment wycięty
// ...
if (MsgLength > MAX_MSG_LEN) MsgLength = MAX_MSG_LEN; // GG_Error();
Msg.Message = AnsiString::StringOfChar(0, MsgLength);
memcpy((char *) Msg.Message.data(), Message.message, MsgLength);
this->Message(this, &Msg);
}
else if (RHead.Type == DEX_GG_SEND_MSG_ACK)
{
TGG_Send_MSG_Ack ack;
memset( &ack, 0, sizeof(TGG_Send_MSG_Ack));
Recv( &ack, RHead.Length);
TGG_MSG_Ack ACK;
ACK.State = ConvertACK(ack.stan);
ACK.Recipient = ack.recipient;
ACK.Sequence = ack.seq;
ConfirmMsg(this, &ACK);
}
else if (RHead.Type == DEX_GG_LOGIN_FAILED)
{
GG_Error(101, "Błąd logowania");
Logout(); // -> TCP_Disconnect -> OnDisconnect
return;
}
else if (RHead.Type == DEX_GG_DISCONNECTING)
{
GG_Error(12, "Serwer Gadu Gadu rozłączył Cię");
Logout(); // Disconnect
return;
}
else // Nie wiadomo co?!
{
// ...
// Fragment wycięty
// ...
}
}
}
//---------------------------------------------------------------------------
void __fastcall TGG::Debug(unsigned char *Data, unsigned int Len)
{
UnicodeString Out = "";
for (unsigned int i = 0; i < Len; i++)
{
Out += IntToHex(Data[i], 2) + " ";
if ((i + 1) % 4 == 0) Out += " ";
}
GG_Error(668, Out);
}
//---------------------------------------------------------------------------
//void __fastcall TGG::TCP_Connect(TObject *Sender, TCustomWinSocket *Socket) { }
void __fastcall TGG::TCP_Disconnect(TObject *Sender, TCustomWinSocket *Socket)
{
Zalogowany = false;
if (AutoConnect) Pinger->Interval = 10 *1000; // 10 sec
else Pinger->Enabled = false;
Disconnect(this);
}
//---------------------------------------------------------------------------
void __fastcall TGG::TCP_Error(TObject *Sender, TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
UnicodeString Error = "";
switch (ErrorEvent)
{
case eeConnect:
Error = "Błąd prz podłączaniu do serwera";
break;
case eeSend:
Error = "Błąd w wysyłaniu";
break;
case eeReceive:
Error = "Błąd w odbieraniu danych";
break;
case eeDisconnect:
Error = "Błąd w rozłączaniu";
break;
case eeAccept:
Error = "Błąd przy próbie akceptacji połączenia klienta";
break;
case eeGeneral:
Error = "Wystąpił nieokreślony błąd w komunikacji";
break;
default:
Error = "Nieznany błąd";
}
GG_Error(ErrorCode, Error);
TCP->Close();
Disconnect(this); // Experimental
//Logout(); // Experimental
ErrorCode = 0;
}
//---------------------------------------------------------------------------
void __fastcall TGG::GG_Error(int ErrorID, UnicodeString Msg)
{
Error(this, ErrorID, Msg);
if (ErrorID != 0) MessageBoxW(NULL, Msg.w_str(), NULL, MB_OK | MB_ICONHAND); // Default
}
bool __fastcall TGG::SendMessage(int Uin, UnicodeString Message, TGGMsgClass Class)
{
return SendMessageEx(Uin, UTF8ToAnsi(Message), Message.Length(), DateTimeToUnix(TDateTime::CurrentDateTime()), Class);
}
//---------------------------------------------------------------------------
bool __fastcall TGG::SendMessageEx(int Uin, Byte *Message, int Length, int Sequence, TGGMsgClass Class)
{
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
int __fastcall TGG::Send(TDataStream &Data, int MessageType)
{
GG_Header Head = {
MessageType, Data.GetLength()
};
Send( &Head, sizeof(GG_Header));
Send(Data.GetData(), Head.Length);
return Head.Length;
}
//---------------------------------------------------------------------------
bool __fastcall TGG::SendImage(int Uin, UnicodeString FilePath)
{
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
unsigned int __fastcall TGG::GetCRC32(const unsigned char *Data, const unsigned int Size)
{
const static unsigned int CRCTable[] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
// ...
// Fragment wycięty
// ...
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
unsigned int CRC32 = 0xFFFFFFFF;
for (unsigned long int i = 0; i < Size; i++)
{
CRC32 = (CRC32 >> 6) ^ CRCTable[(CRC32 &0xFF) ^ Data[i]];
}
CRC32 ^= 0xFFFFFFFF;
return CRC32;
}
//---------------------------------------------------------------------------//
// Inne //
//---------------------------------------------------------------------------//
int __fastcall TGG::Send(void *Data, int Len)
{
return TCP->Socket->SendBuf(Data, Len);
}
int __fastcall TGG::Recv(void *Data, int Len)
{
return TCP->Socket->ReceiveBuf(Data, Len);
}
void __fastcall TGG::HClear()
{
RHead.Type = 0;
RHead.Length = 0;
}
//---------------------------------------------------------------------------
int __fastcall TGG::GetPort()
{
return TCP->Port;
}
void __fastcall TGG::SetPort(int Val)
{
TCP->Port = Val;
}
void __fastcall TGG::SetVersion(TGGClientVersion Val)
{
if (IsLogged() == false) FVersion = Val;
}
System::UnicodeString __fastcall TGG::GetHost()
{
return TCP->Host;
}
void __fastcall TGG::SetHost(System::UnicodeString Val)
{
TCP->Host = Val;
}
//---------------------------------------------------------------------------
char *__fastcall TGG::UTF8ToAnsi(UnicodeString UString)
{
return AnsiString(UString).c_str();
}
//---------------------------------------------------------------------------
void __fastcall TGG::GetGGHost()
{
AnsiString Source = "http://appmsg.gadu-gadu.pl/appsvc/appmsg4.asp?fmnumber=" + IntToStr(Uin) + "&&version=7,7,0,3315&&lastmsg=1";
AnsiString IP = "";
Port = 0;
HINTERNET hSession;
hSession = InternetOpenA("", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hSession)
{
HINTERNET hService;
hService = InternetOpenUrlA(hSession, Source.c_str(), NULL, 0, 0, 0);
if (hService)
{
while (true)
{
char lpBuffer[1024 + 1];
DWORD dwBytesRead;
InternetReadFile(hService, lpBuffer, 1024, &dwBytesRead);
if (dwBytesRead <= 0) break;
lpBuffer[dwBytesRead] = 0;
IP += lpBuffer;
}
}
InternetCloseHandle(hService);
}
InternetCloseHandle(hSession);
// ...
// Fragment wycięty
// ...
Host = IP;
}
//---------------------------------------------------------------------------
int __fastcall TGG::HashUIN(const unsigned char *password, int seed)
{
Byte *Pass = new Byte[strlen(password) + 1];
memset(Pass, 0, strlen(password) + 1);
memcpy(Pass, password, strlen(password));
unsigned int x, y, z;
y = seed;
for (x = 0; *Pass; Pass++)
{
x = (x &0xFFFFFF00) | *Pass;
y ^= x;
y += x;
x <<= 8;
y ^= x;
x <<= 8;
y -= x;
x <<= 8;
y ^= x;
z = y &0x1F;
y = (y << z) | (y >> (32 - z));
}
return y;
}
//---------------------------------------------------------------------------
// ...
// Fragment wycięty
// ...
//---------------------------------------------------------------------------
void __fastcall TGG::SendUserList()
{
TNotifyUser *Aktualny = UserList->GetFirst();
while (Aktualny)
{
TDataStream User;
User.Add(Aktualny->uin);
User.Add < char > (Aktualny->Type);
Send(User, DEX_GG_ADD_NOTIFY);
Aktualny = Aktualny->next;
//Application->ProcessMessages();
}
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TGG::ConvertIP(int IP)
{
BYTE a, b, c, d;
a = (IP &0xFF000000) >> 24;
// ...
// Fragment wycięty
// ...
return Format("%d.%d.%d.%d", ARRAYOFCONST((d, c, b, a)));
}
//---------------------------------------------------------------------------
TGGUinFlag __fastcall TGG::ConvertUinFlag(Byte Flag)
{
switch (Flag)
{
case DEX_GG_UINFLAG_UNKNOWN2:
return ufInvisible;
case DEX_GG_UINFLAG_VOICE:
return ufVoice;
case DEX_GG_UINFLAG_ERA_OMNIX:
return ufEraOmnix;
default:
return ufUnknown;
}
}
//---------------------------------------------------------------------------
TGG_UserStatus __fastcall TGG::ConvertUserStatus(Byte Status)
{
switch (Status)
{
case DEX_GG_STATUS_NOT_AVAIL:
case DEX_GG_STATUS_NOT_AVAIL_DESCR:
return usNotAvailable;
case DEX_GG_STATUS_AVAIL:
case DEX_GG_STATUS_AVAIL_DESCR:
return usAvailable;
// ...
// Fragment wycięty
// ...
}
return usAvailable;
}
//---------------------------------------------------------------------------
TGGMsgClass __fastcall TGG::ConvertMsgClass(Byte Status)
{
switch (Status)
{
case DEX_GG_CLASS_QUEUED:
return msQueued;
case DEX_GG_CLASS_MSG:
return msNewWindow;
case DEX_GG_CLASS_CHAT:
return msChat;
case DEX_GG_CLASS_CTCP:
return msTCP;
case DEX_GG_CLASS_ACK:
return msNoACK;
default:
return msChat;
}
}
//---------------------------------------------------------------------------
unsigned long int TGG::DateTimeToUnix(TDateTime ConvDate)
{
return Round((ConvDate - TDateTime(25569.0)) *86400);
}
TDateTime __fastcall TGG::UnixToDateTime(unsigned long int USec)
{
return TDateTime(USec / 86400.0) + TDateTime(25569.0);
}
//---------------------------------------------------------------------------
__fastcall TGG::~TGG()
{
AutoConnect = false;
if (IsLogged()) Logout();
delete UserList;
UserList = NULL;
delete TCP;
TCP = NULL;
delete Pinger;
Pinger = NULL;
}
//---------------------------------------------------------------------------
namespace Tgg
{
void __fastcall PACKAGE Register()
{
TComponentClass classes[1] = {
__classid(TGG)
};
RegisterComponents(L "Internet", classes, 0);
}
}
TVarList - Zastosowanie
/*********************************************************/
/* NADAWCA */
/*********************************************************/
{
bool zmienna_bool = true;
TVarList Vars;
Vars << "Napis" << 15 << zmienna_bool << 3.14; // Dodajemy zmienne (dowolnego typu) do strumienia danych
int rozmiar;
void* Dane;
Vars.Serialize(Dane, rozmiar); // Zapisujemy zmienne do bufora danych "Dane"...
socket.send(Dane, rozmiar); // ... i wysyłamy go
}
/*********************************************************/
/* ODBIORCA */
/*********************************************************/
{
int rozmiar;
void* OdebraneDane;
socket.receive(OdebraneDane, rozmiar); // odbieramy bufor danych z wysłanymi zmiennymi
TVarList Vars;
Vars.Unserialize(OdebraneDane);
char *Napis = Vars[0]->Value; // Strumień "wie" jakiego typu przechowuje zmienne
int liczba = Vars[1]->Value; // i automatycznie zwraca wymagany typ danych
bool zmienna_bool = Vars[2]->Value; // bez potrzeby rzutowania ;
float pi = Vars[3]->Value;
}
TVarList - Fragmenty kodu
// ...
// Fragment wycięty
// ...
enum TVarMainType
{
vm_UNKNOWN, vm_NUMERIC, vm_STRING, vm_DATA
};
enum TVarSign
{
vs_Unknown, vs_Signed, vs_Unsigned
};
enum TVarSubType
{
st_Unknown, st_Char, st_WChar_t, st_Short, st_Int, st_Int64, st_Float, st_Double, st_LongDouble
};
class TMyVarType
{
protected: TVarMainType Type;
TVarSign Scope;
TVarSubType Details;
bool Pointer;
public: TMyVarType(): Type(vm_UNKNOWN),
Scope(vs_Unknown),
Details(st_Unknown),
Pointer(false)
{}
TMyVarType &operator << (TVarMainType Type)
{
this->Type = Type;
return *this;
};
TMyVarType &operator << (TVarSign Scope)
{
this->Scope = Scope;
return *this;
};
TMyVarType &operator << (TVarSubType Details)
{
this->Details = Details;
return *this;
};
TMyVarType &operator << (bool Pointer)
{
this->Pointer = Pointer;
return *this;
};
operator == (TVarMainType Type)
{
return this->Type == Type;
};
operator == (TVarSign Scope)
{
return this->Scope == Scope;
};
operator == (TVarSubType Details)
{
return this->Details == Details;
};
operator == (bool Pointer)
{
return this->Pointer == Pointer;
};
operator TVarMainType()
{
return this->Type;
};
operator TVarSign()
{
return this->Scope;
};
operator TVarSubType()
{
return this->Details;
};
operator bool()
{
return this->Pointer;
};
}; /******************************** TVarNumeric *********************************/
class TVarValue
{
protected: wchar_t *ToUnicode(const char *AnsiText);
char *ToAnsi(const wchar_t *UnicodeText);
wchar_t *CopyStr(const wchar_t *UnicodeText);
char *CopyStr(const char *AnsiText);
char *GetAs_char();
wchar_t *GetAs_wchar_t();
template < class T > T GetAs_others();
friend class TVarItem;
TVarItem *Owner_Item;
public:
explicit operator char *();
explicit operator const char *();
explicit operator AnsiString();
explicit operator wchar_t *();
explicit operator const wchar_t *();
explicit operator UnicodeString();
template < class T > operator T();
};
/********************************** TVarList *********************************/
class TVarList
{
private: typedef unsigned char BYTE;
friend class TVarValue;
unsigned int BYTE_size;
unsigned int package_size;
unsigned int TotalSize;
protected: TPtrList *List;
bool SkipPattern(AnsiString &Base, AnsiString Pattern);
template < class T > TMyVarType GetTypeOf(T Var);
public: TVarList();~TVarList();
//---
template < class T > TVarList &Add(T Value);
TVarList &AddString(const char *cString);
TVarList &AddString(const wchar_t *wString);
TVarList &AddData(void *Data, unsigned int Length, bool Reference = true);
//---
template < class T > TVarList &operator << (T Value);
TVarList &operator << (const char *Value);
TVarList &operator << (char *Value);
TVarList &operator << (const wchar_t *Value);
TVarList &operator << (wchar_t *Value);
TVarList &operator << (AnsiString Value); //friend TVarList& operator << (TVarList& List, AnsiString Value);
TVarList &operator << (UnicodeString Value);
TVarList &operator << (VAR_DATA Data);
TVarItem *operator[](unsigned int Index)
{
return (TVarItem *) List->Item[Index]->Data;
}
void Seralize(void *& OutputData, unsigned int &Length);
bool Unseralize(const void *InputData);
};
// ...
// Fragment wycięty
// ...
//TVarList& operator << (TVarList& List, AnsiString Value)
template < > TVarList &TVarList::operator << (const char *Value)
{
return AddString(Value);
}
template < > TVarList &TVarList::operator << (char *Value)
{
return AddString(Value);
}
template < > TVarList &TVarList::operator << (const wchar_t *Value)
{
return AddString(Value);
}
template < > TVarList &TVarList::operator << (wchar_t *Value)
{
return AddString(Value);
}
template < > TVarList &TVarList::operator << (AnsiString Value)
{
return AddString(Value.c_str());
}
template < > TVarList &TVarList::operator << (UnicodeString Value)
{
return AddString(Value.w_str());
}
template < > TVarList &TVarList::operator << (VAR_DATA Data)
{
return AddData(Data.Data, Data.Length, Data.Reference);
}
template < class T > TVarList &TVarList::operator << (T Value)
{
return Add(Value);
}
// ...
// Fragment wycięty
// ...
TVarList::TVarList(): TotalSize(4)
{
List = new TPtrList(NULL);
List->AllocBy = 6;
BYTE_size = sizeof(BYTE);
package_size = sizeof(unsigned int) + (3 *BYTE_size) + sizeof(bool);
}
//---------------------------------------------------------------------------
TVarList::~TVarList()
{
TotalSize = 0;
for (unsigned int i = 0; i < List->Count; i++)
{
TVarItem *Item = this->operator[](i);
if (Item->Reference == false)
{
if (Item->Data) delete[] Item->Data;
Item->Data = NULL;
}
}
List->Clear();
}
//---------------------------------------------------------------------------
template < class T > TMyVarType TVarList::GetTypeOf(T Var)
{
const std::type_info &Type = typeid(Var);
const char *cTypeName = Type.name();
int status = 0;
#ifdef ABI_DEMANGLE
#include < cxxabi.h >
cTypeName = abi::__cxa_demangle(cTypeName, 0, 0, &status);
#endif
if (cTypeName[0] == '\0' || status != 0) throw Exception("TVarList: Can't obtain variable type!");
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
TVarList &TVarList::AddString(const wchar_t *wString)
{
TVarItem *Var = new TVarItem(this);
Var->Type << vm_STRING << st_WChar_t;
Var->DataLength = wcslen(wString) *sizeof(wchar_t) + 1;
wchar_t *CopyStr = new wchar_t[Var->DataLength + 1];
_wcspcpy(CopyStr, wString);
Var->Data = CopyStr;
List->Add(Var);
TotalSize += Var->DataLength + package_size;
return *this;
}
//---------------------------------------------------------------------------
TVarList &TVarList::AddString(const char *cString)
{
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
TVarList &TVarList::AddData(void *Data, unsigned int Length, bool Reference)
{
TVarItem *Var = new TVarItem(this);
Var->Type << vm_DATA;
Var->DataLength = Length;
if (Reference)
{
Var->Data = Data;
}
else
{
BYTE *CopyData = new BYTE[Length + 1];
memcpy(CopyData, Data, Length);
Var->Data = CopyData;
}
Var->Reference = Reference;
List->Add(Var);
TotalSize += Var->DataLength + package_size;
return *this;
}
//---------------------------------------------------------------------------
template < class T > TVarList &TVarList::Add(T Value)
{
TVarItem *Var = new TVarItem(this);
Var->Type = GetTypeOf(Value);
if (Var->Type == vm_NUMERIC)
{
T *NewValue = new T; *NewValue = Value;
Var->DataLength = sizeof(T);
Var->Data = NewValue;
}
List->Add(Var);
TotalSize += Var->DataLength + package_size;
return *this;
}
//---------------------------------------------------------------------------
void TVarList::Seralize(void *& OutputData, unsigned int &Length)
{
Length = TotalSize;
OutputData = new unsigned char[TotalSize];
memset(OutputData, 0, TotalSize);
BYTE *Ptr = (BYTE *) OutputData; *Ptr = List->Count;
Ptr += sizeof(List->Count);
for (unsigned int i = 0; i < List->Count; i++)
{
TVarItem *Item = this->operator[](i);
TVarMainType Type = Item->Type;
TVarSign Scope = Item->Type;
TVarSubType Details = Item->Type;
bool Pointer = Item->Type;
*Ptr = (BYTE) Type;
Ptr += BYTE_size; *Ptr = (BYTE) Scope;
Ptr += BYTE_size; *Ptr = (BYTE) Details;
Ptr += BYTE_size; *Ptr = (BYTE) Pointer;
Ptr += BYTE_size;
*Ptr = Item->DataLength;
Ptr += sizeof(Item->DataLength);
memcpy(Ptr, Item->Data, Item->DataLength);
Ptr += Item->DataLength;
}
}
//---------------------------------------------------------------------------
bool TVarList::Unseralize(const void *InputData)
{
if (InputData == NULL) return false;
BYTE *Ptr = (BYTE *) InputData;
unsigned int Count = *reinterpret_cast < unsigned int *> (Ptr);
Ptr += sizeof(unsigned int);
if (Count == 0) return false;
List->Clear();
for (unsigned int i = 0; i < Count; i++)
{
TVarMainType Type = *reinterpret_cast < BYTE *> (Ptr);
Ptr += BYTE_size;
TVarSign Scope = *reinterpret_cast < BYTE *> (Ptr);
Ptr += BYTE_size;
TVarSubType Details = *reinterpret_cast < BYTE *> (Ptr);
Ptr += BYTE_size;
bool Pointer = *reinterpret_cast < bool *> (Ptr);
Ptr += sizeof(bool);
TVarItem *Item = new TVarItem(this);
Item->Type << Type << Scope << Details << Pointer;
Item->DataLength = *reinterpret_cast < unsigned int *> (Ptr);
Ptr += sizeof(unsigned int);
if (Item->DataLength == 0) return false;
BYTE *Data = new BYTE[Item->DataLength];
memcpy(Data, Ptr, Item->DataLength);
Item->Data = Data;
Ptr += Item->DataLength;
List->Add(Item);
TotalSize += Item->DataLength + package_size;
}
return true;
}
// ...
// Fragment wycięty
// ...
/***************************** TVarValue ************************************/
//---------------------------------------------------------------------------
wchar_t *TVarValue::ToUnicode(const char *AnsiText)
{
unsigned int Len = strlen(AnsiText);
wchar_t *UniBuffer = new wchar_t[Len + 1];
MultiByteToWideChar(CP_ACP, 0, AnsiText, Len, UniBuffer, Len + 1);
UniBuffer[Len] = '\0';
return UniBuffer;
}
//---------------------------------------------------------------------------
char *TVarValue::ToAnsi(const wchar_t *UnicodeText)
{
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
wchar_t *TVarValue::CopyStr(const wchar_t *UnicodeText)
{
if (!UnicodeText) return NULL;
wchar_t *UnicodeBuffer = new wchar_t[wcslen(UnicodeText) + 1];
_wcspcpy(UnicodeBuffer, UnicodeText);
return UnicodeBuffer;
}
//---------------------------------------------------------------------------
char *TVarValue::CopyStr(const char *AnsiText)
{
// ...
// Fragment wycięty
// ...
}
//---------------------------------------------------------------------------
template < typename T > T TVarValue::GetAs_others()
{
ShowMessage("Wants return: " + AnsiString(typeid(T).name()));
T _temp;
TMyVarType TypeToReturn = Owner_Item->Owner_List->GetTypeOf(_temp);
TMyVarType TypeOfVar = Owner_Item->Type;
if (TypeToReturn == vm_NUMERIC)
{
if (TypeOfVar == vm_NUMERIC)
{
if (TypeOfVar == st_Char) return (T) *reinterpret_cast < char *> (Owner_Item->Data);
else if (TypeOfVar == st_WChar_t) return (T) *reinterpret_cast < wchar_t *> (Owner_Item->Data);
else if (TypeOfVar == st_Short) return (T) *reinterpret_cast < short *> (Owner_Item->Data);
else if (TypeOfVar == st_Int) return (T) *reinterpret_cast < int *> (Owner_Item->Data);
else if (TypeOfVar == st_Int64) return (T) *reinterpret_cast < long long int *> (Owner_Item->Data);
else if (TypeOfVar == st_Float) return (T) *reinterpret_cast < float *> (Owner_Item->Data);
else if (TypeOfVar == st_Double) return (T) *reinterpret_cast < double *> (Owner_Item->Data);
else if (TypeOfVar == st_LongDouble) return (T) *reinterpret_cast < long double *> (Owner_Item->Data);
}
else if (TypeOfVar == vm_DATA)
{
return *reinterpret_cast < T *> (Owner_Item->Data);
}
}
return 0; // Error
}
//---------------------------------------------------------------------------
char *TVarValue::GetAs_char()
{
if (!Owner_Item || Owner_Item->DataLength == 0) return ""; // Error
if (Owner_Item->Type == vm_STRING)
{
if (Owner_Item->Type == st_Char)
{
return (char *) Owner_Item->Data; // CopyStr((char *) Owner_Item->Data);
}
if (Owner_Item->Type == st_WChar_t)
{
return ToAnsi((wchar_t *) Owner_Item->Data);
}
}
return ""; // Error
}
//---------------------------------------------------------------------------
// ...
// Fragment wycięty
// ...
//---------------------------------------------------------------------------
template < > TVarValue::operator AnsiString()
{
return GetAs_char();
}
template < > TVarValue::operator UnicodeString()
{
return GetAs_wchar_t();
}
template < > TVarValue::operator char *()
{
return GetAs_char();
}
template < > TVarValue::operator const char *()
{
return GetAs_char();
}
template < > TVarValue::operator wchar_t *()
{
return GetAs_wchar_t();
}
template < > TVarValue::operator const wchar_t *()
{
return GetAs_wchar_t();
}
template < class T > TVarValue::operator T()
{
return GetAs_others < T > ();
}
//---------------------------------------------------------------------------
Wybrane projekty PHP
Strony WWW:
-
Strona Klasowa
Pierwsza strona internetowa w mojej karierze, stworzona dla mojej klasy w liceum. Przez 4 lata zajmowałem się również administracją. Strona była codziennie aktualizowana.
Dostępne na niej były:- kronika klasy
- informacje o najbliższych pracach domowych, kartkówkach i sprawdzianach
- Terminarz
- Plan lekcji
- Panel skarbnika – informacje o zaległych płatnościach.
- Lista uczniów i ich osiągnięć
- Galeria zdjęć z klasowych eventów i wycieczek
- Zintegrowane ze stroną forum
Strona zajęła II miejsce w międzynarodowym konkursie JuniorWeb. Polecam przejrzeć prezentację multimedialną na jej temat. -
aleBrechta.pl - Boki zrywać
Luźna strona stworzona przeze mnie przede wszystkim dla rozrywki. Spośród konkurencji wyróżnia ją czysty i jasny layout. Niespodziewanie dla mnie posiada sporą oglądalność.
-
Zobaczyć Matematykę
Strona napisana na potrzeby konkursu "Zobaczyć matematykę" organizowanego przez Uniwersytet Jagielloński.
Tematem mojej pracy była "Interpolacja biliniowa".
-
Mary Kay – Lublin
Strona firmowa Lubelskiego oddziału międzynarodowej firmy MaryKay.
Aktualnie (po 2 latach) firma posiada nowszą i bardziej rozbudowaną stronę.
-
Dex Framework 2.03
Mój autorski framework, przystosowany do mojego stylu programowania. Składniowo bardzo podobny do Zend frameworka lecz znacznie od niego szybszy. Zawiera wszystkie niezbędne klasy do stworzenia kompletnego portalu WWW!
-
Translator z Delphi na C++ Builder
Zafascynowany wyrażeniami regularnymi stworzyłem translator Delphi na C++ Builder (lub też Pascal -> C++), który całkiem nieźle sobie radzi nawet z bardzo złożonymi kodami.
Wybrane projekty C#
Aplikacje z GUI:
-
Potomkowie Adama i Ewy
Program generujący, na podstawie danych z Internetu, drzewo genealogiczne począwszy od Adama i Ewy aż do Jezusa Chrystusa. Dużą rolę odgrywają w nim wyrażenia regularne oraz rekurencja. -
Pole grawitacyjne kursora
Program generujący na ekranie prostokąty i (jeśli się one pokrywają) zaznaczający ich części wspólne. Pointą programu jest wykrywanie wierzchołków i w przypadku zbliżenia kursora do takowych, przyciągnięcie go. -
Bot Smart-Spam
Program wyszukuje aktywnych użytkowników danej strony WWW po czym rozpoczyna rozmowę, w której nakłania do odwiedzenia zadanego serwisu. Jest to bardzo efektywny sposób rozsyłania spamu. Z moich statystyk wynika 95% użytkowników, którzy wdali się w "rozmowę" z botem odwiedziło podlinkowaną stronę.
Wybrane projekty C++
Aplikacje z GUI:
-
Zdalny pulpit
Program typu klient – serwer – klient. Pozwala na zdalne zarządzanie pulpitem innego komputera lub jedynie jego zasobami (bez zauważalnej ingerencji po stronie klienta).
Program przydatny, gdy:- Korzystając z nieswojego komputera chcemy wysłać lub pobrać dowolny plik z własnego komputera.
- Chcemy kontrolować innych użytkowników komputera (np. dzieci).
- Chcemy śledzić historię działań użytkownika (np. pracownika) – logi, raporty, historia odwiedzanych stron, statystyki itp.
- Chcemy odzyskać skradzionego laptopa. Możliwość geolokalizacji oraz przechwytywania zdjęć z kamerki internetowej.
-
TVarList
Bardzo ciekawy komponent pozwalający na strumieniowanie dowolnych zmiennych. Można dzięki niemu stworzyć listę zmiennych dowolnego typu, wysłać je do innego programu i odwoływać się do nich przez proste indeksowanie. -
TGG
Komponent dający możliwość pełnej obsługi protokołu Gadu-Gadu. -
TProcess
Komponent umożliwiający zarządzanie procesami systemu. Pozwala na „zabicie” dowolnego (nawet systemowego) procesu, jego „zamrożenie” i wiele więcej. -
TWndMessage
Komponent umożliwia wymianę danych między odrębnymi aplikacjami działającymi na jednym komputerze (poprzez komunikaty). -
TPtrQueue
Uniwersalna lista dwukierunkowa. Jej niewątpliwą zaletą jest przechowywanie wskaźnika do pierwszego, ostatniego, środkowego oraz ostatnio zwracanego elementu, dzięki czemu lista jest znacznie szybsza od standardowych list tego typu. Posiada wiele więcej udogodnień (np. auto-sortowanie elementów listy w ustalonym kierunku itd.).
-
Słowik
Program jest bardzo pomocny w nauce języka obcego. Pozwala na tworzenia własnych słowników, z których użytkownik jest następnie odpytywany. Pomaga szybko opanować nowo poznane słówka. -
Saper Bot
Program rozwiązujący planszę do gry "SAPER". Analizuje on pole gry w czasie rzeczywistym i na podstawie zebranych danych podejmuje decyzje. Rozwiązanie planszy na poziomie EXPERT zajmuje mu 1s. -
TConsole
Klasa do kompleksowej obsługi konsoli. Zmiana koloru, rozmiaru czcionki czy okna to tylko kropla w morzu możliwości tej klasy. -
Tetris
Jedna z pierwszych gier, w mojej karierze (były jeszcze „tor saneczkowy” i „labirynt”).
