procxx
/
kepka
mirror of https://github.com/procxx/kepka.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Remove obsolete files

This commit is contained in:
Berkus Decker 2017-11-20 22:10:26 +02:00 committed by Berkus Decker
parent 8e9eea0673
commit d95e41572f
39 changed files with 0 additions and 5237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
Telegram/Patches/mini_chromium.diff
View File

@ -1,52 +0,0 @@
diff --git a/base/mac/scoped_nsobject.h b/base/mac/scoped_nsobject.h
index 2e157a4..5a306a1 100644
--- a/base/mac/scoped_nsobject.h
+++ b/base/mac/scoped_nsobject.h
@@ -11,6 +11,7 @@
#include "base/compiler_specific.h"
#include "base/mac/scoped_typeref.h"
+#include "base/template_util.h"
namespace base {
@@ -55,7 +56,7 @@ class scoped_nsobject : public scoped_nsprotocol<NST*> {
public:
using scoped_nsprotocol<NST*>::scoped_nsprotocol;
- static_assert(std::is_same<NST, NSAutoreleasePool>::value == false,
+ static_assert(is_same<NST, NSAutoreleasePool>::value == false,
"Use ScopedNSAutoreleasePool instead");
};
diff --git a/base/macros.h b/base/macros.h
index 5d96783..096704c 100644
--- a/base/macros.h
+++ b/base/macros.h
@@ -42,8 +42,9 @@ char (&ArraySizeHelper(const T (&array)[N]))[N];
template <typename Dest, typename Source>
inline Dest bit_cast(const Source& source) {
+#if __cplusplus >= 201103L
static_assert(sizeof(Dest) == sizeof(Source), "sizes must be equal");
-
+#endif
Dest dest;
memcpy(&dest, &source, sizeof(dest));
return dest;
diff --git a/build/common.gypi b/build/common.gypi
index 1affc70..6e8f292 100644
--- a/build/common.gypi
+++ b/build/common.gypi
@@ -66,6 +66,11 @@
'conditions': [
['clang!=0', {
'CLANG_CXX_LANGUAGE_STANDARD': 'c++11', # -std=c++11
+ 'conditions': [
+ ['mac_deployment_target=="10.8"', {
+ 'CLANG_CXX_LIBRARY': 'libc++', # force -stdlib=libc++ for 10.8
+ }]
+ ],
# Don't link in libarclite_macosx.a, see http://crbug.com/156530.
'CLANG_LINK_OBJC_RUNTIME': 'NO', # -fno-objc-link-runtime

22
Telegram/Patches/openal.diff
View File

@ -1,22 +0,0 @@
diff --git a/Alc/backends/winmm.c b/Alc/backends/winmm.c
index 9d8f8e9..8c8e44a 100644
--- a/Alc/backends/winmm.c
+++ b/Alc/backends/winmm.c
@@ -219,7 +219,7 @@ FORCE_ALIGN static int ALCwinmmPlayback_mixerProc(void *arg)
SetRTPriority();
althrd_setname(althrd_current(), MIXER_THREAD_NAME);
- while(GetMessage(&msg, NULL, 0, 0))
+ if (!self->killNow) while(GetMessage(&msg, NULL, 0, 0))
{
if(msg.message != WOM_DONE)
continue;
@@ -504,7 +504,7 @@ static int ALCwinmmCapture_captureProc(void *arg)
althrd_setname(althrd_current(), RECORD_THREAD_NAME);
- while(GetMessage(&msg, NULL, 0, 0))
+ if (!self->killNow) while(GetMessage(&msg, NULL, 0, 0))
{
if(msg.message != WIM_DATA)
continue;

0
Telegram/SetupFiles/data
View File

0
Telegram/SetupFiles/log.txt
View File

717
Telegram/SourceFiles/base/virtual_method.h
View File

@ -1,717 +0,0 @@
/*
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
*/
#pragma once
namespace base {
template <typename Object, typename ParentObject = void>
class virtual_object;
template <typename ConcreteMethod, typename ReturnType, typename ...Args>
class virtual_method;
template <typename ConcreteMethod, typename BaseMethod>
class virtual_override;
namespace virtual_methods {
struct child_entry;
using is_parent_check = bool(*)(const child_entry &possible_parent);
struct child_entry {
is_parent_check check_is_parent;
int *table_index;
};
using child_entries = std::vector<child_entry>;
// Recursive method to find if some class is a child of some other class.
template <typename ConcreteObject>
struct is_parent {
static inline bool check(const child_entry &possible_parent) {
// Generate a good error message if ConcreteObject is not a child of virtual_object<>.
using all_objects_must_derive_virtual_object = typename ConcreteObject::virtual_object_parent;
using ConcreteObjectParent = all_objects_must_derive_virtual_object;
return (possible_parent.check_is_parent == &is_parent<ConcreteObject>::check)
|| is_parent<ConcreteObjectParent>::check(possible_parent);
}
};
template <>
struct is_parent<void> {
static inline bool check(const child_entry &possible_parent) {
return (possible_parent.check_is_parent == &is_parent<void>::check);
}
};
// Just force the compiler not to optimize away the object that "enforce" points at.
inline void dont_optimize_away(void *enforce) {
static volatile void *result = nullptr;
if (result) {
result = enforce;
}
}
template <typename Type, Type Value>
struct dont_optimize_away_struct {
};
inline bool first_dispatch_fired(bool did_fire = false) {
static bool fired = false;
if (did_fire) {
fired = true;
}
return fired;
}
template <typename Object, void (*Creator)(const child_entry &)>
class object_registrator {
public:
inline object_registrator() {
Assert(!first_dispatch_fired());
Creator(child_entry {
&is_parent<Object>::check,
&_index,
});
}
static inline int &Index() {
return _index;
}
private:
static int _index;
};
template <typename Object, void (*Creator)(const child_entry &)>
int object_registrator<Object, Creator>::_index = -1;
class object_base {
protected:
virtual ~object_base() = default;
};
template <typename ...ConcreteArgs>
struct multi_index_collector;
template <int M, typename ...ConcreteArgs>
struct override_key_collector_helper;
template <typename Call, typename ...Args>
struct table_fill_entry_helper;
template <typename ...Args>
struct table_count_size;
} // namespace virtual_methods
// This should be a base class for every child object in your hierarchy.
// It registers this child in the root virtual_objects classes list.
// Also it holds its own index in the classes list that is used for fast
// invoking of methods from the virtual tables in different virtual_methods.
template <typename Object, typename ParentObject>
class virtual_object : public ParentObject {
protected:
virtual ~virtual_object() {
virtual_methods::dont_optimize_away(&_virtual_object_registrator);
}
private:
using virtual_object_parent = ParentObject;
friend struct virtual_methods::is_parent<Object>;
template <typename ...Args>
friend struct virtual_methods::multi_index_collector;
template <int M, typename ...ConcreteArgs>
friend struct virtual_methods::override_key_collector_helper;
template <typename OtherObject, typename OtherParentObject>
friend class virtual_object;
template <typename BaseMethod, typename ReturnType, typename ...Args>
friend class virtual_method;
static inline void virtual_object_register_child(const virtual_methods::child_entry &entry) {
return ParentObject::virtual_object_register_child(entry);
}
using virtual_object_registrator = virtual_methods::object_registrator<Object, &virtual_object::virtual_object_register_child>;
static virtual_object_registrator _virtual_object_registrator;
using virtual_object_dont_optimize_away_registrator = virtual_methods::dont_optimize_away_struct<virtual_object_registrator*, &_virtual_object_registrator>;
static inline int &virtual_object_child_index_static() {
return virtual_object_registrator::Index();
}
int &virtual_object_child_index() override {
return virtual_object_child_index_static();
}
};
template <typename Object, typename ParentObject>
typename virtual_object<Object, ParentObject>::virtual_object_registrator virtual_object<Object, ParentObject>::_virtual_object_registrator = {};
// This should be a base class for the root of the whole hierarchy.
// It holds the table of all child classes in a list.
// This list is used by virtual_methods to generate virtual table.
template <typename Object>
class virtual_object<Object, void> : public virtual_methods::object_base {
protected:
virtual ~virtual_object() {
virtual_methods::dont_optimize_away(&_virtual_object_registrator);
}
private:
using virtual_object_parent = void;
friend struct virtual_methods::is_parent<Object>;
template <typename ...Args>
friend struct virtual_methods::table_count_size;
template <typename ...Args>
friend struct virtual_methods::multi_index_collector;
template <int M, typename ...ConcreteArgs>
friend struct virtual_methods::override_key_collector_helper;
template <typename Call, typename ...Args>
friend struct virtual_methods::table_fill_entry_helper;
template <typename OtherObject, typename OtherParentObject>
friend class virtual_object;
template <typename BaseMethod, typename ReturnType, typename ...Args>
friend class virtual_method;
static inline virtual_methods::child_entries &virtual_object_get_child_entries() {
static virtual_methods::child_entries entries;
return entries;
}
// Registers a new child class.
// After that on the next call to virtual_method::virtual_method_prepare_table() will
// generate a new virtual table for that virtual method.
static inline void virtual_object_register_child(const virtual_methods::child_entry &entry) {
auto &entries = virtual_object_get_child_entries();
for (auto i = entries.begin(), e = entries.end(); i != e; ++i) {
if (entry.check_is_parent(*i)) {
*entry.table_index = (i - entries.begin());
i = entries.insert(i, entry);
for (++i, e = entries.end(); i != e; ++i) {
++*(i->table_index);
}
return;
}
}
*entry.table_index = entries.size();
entries.push_back(entry);
}
using virtual_object_registrator = virtual_methods::object_registrator<Object, &virtual_object::virtual_object_register_child>;
static virtual_object_registrator _virtual_object_registrator;
using virtual_object_dont_optimize_away_registrator = virtual_methods::dont_optimize_away_struct<virtual_object_registrator*, &_virtual_object_registrator>;
static inline int &virtual_object_child_index_static() {
return virtual_object_registrator::Index();
}
virtual int &virtual_object_child_index() {
return virtual_object_child_index_static();
}
};
template <typename Object>
typename virtual_object<Object, void>::virtual_object_registrator virtual_object<Object, void>::_virtual_object_registrator = {};
namespace virtual_methods {
template <typename Arg>
struct is_virtual_argument : public std::integral_constant<bool,
base::type_traits<Arg>::is_pointer::value
? std::is_base_of<object_base, typename base::type_traits<Arg>::pointed_type>::value
: false> {
};
template <int N, int Instance>
class multi_int_wrap {
public:
inline multi_int_wrap(int *indices) : _indices(indices) {
}
inline multi_int_wrap<N - 1, Instance> subindex() const {
static_assert(N > 0, "Wrong multi_int_wrap created!");
return multi_int_wrap<N - 1, Instance>(_indices + 1);
}
inline int &current() const {
return *_indices;
}
private:
int *_indices;
};
template <int Instance>
class multi_int_wrap<0, Instance> {
public:
inline multi_int_wrap(int *indices) {
}
inline int current() const {
return 1;
}
};
template <int N>
using multi_index_wrap = multi_int_wrap<N, 0>;
template <int N>
using multi_size_wrap = multi_int_wrap<N, 1>;
template <typename ConcreteArg, typename ...ConcreteArgs>
struct multi_index_collector<ConcreteArg, ConcreteArgs...> {
static constexpr int N = sizeof...(ConcreteArgs) + 1;
static inline void call(multi_index_wrap<N> indices, ConcreteArg arg, ConcreteArgs... args) {
indices.current() = computeIndex(is_virtual_argument<ConcreteArg>(), arg);
multi_index_collector<ConcreteArgs...>::call(indices.subindex(), args...);
}
static inline int computeIndex(std::integral_constant<bool, false>, ConcreteArg arg) {
return 0;
}
static inline int computeIndex(std::integral_constant<bool, true>, ConcreteArg arg) {
return arg->virtual_object_child_index();
}
};
template <>
struct multi_index_collector<> {
static inline void call(multi_index_wrap<0> indices) {
}
};
template <int N>
class override_key;
template <int N, int Instance>
class multi_int {
public:
inline multi_int_wrap<N, Instance> data_wrap() {
return multi_int_wrap<N, Instance>(_indices);
}
template <typename ...ConcreteArgs>
static inline multi_int<N, Instance> collect(ConcreteArgs... args) {
multi_int<N, Instance> result;
multi_index_collector<ConcreteArgs...>::call(result.data_wrap(), args...);
return result;
}
inline void reset() {
memset(_indices, 0, sizeof(_indices));
}
inline int value(int index) const {
return _indices[index];
}
inline void copy(multi_int_wrap<N, Instance> other) {
memcpy(_indices, &other.current(), sizeof(_indices));
}
private:
int _indices[N] = { 0 };
friend class override_key<N>;
};
template <int N>
using multi_index = multi_int<N, 0>;
template <int N>
using multi_size = multi_int<N, 1>;
template <typename Call, int N>
class table_data_wrap {
public:
inline table_data_wrap(Call *data, multi_size_wrap<N> size) : _data(data), _size(size) {
}
inline table_data_wrap<Call, N - 1> operator[](int index) const {
return table_data_wrap<Call, N - 1>(_data + index * _size.subindex().current(), _size.subindex());
}
inline Call &operator[](multi_index_wrap<N> index) const {
return (*this)[index.current()][index.subindex()];
}
inline int size() const {
return count_size(std::integral_constant<int,N>());
}
private:
template <int M>
inline int count_size(std::integral_constant<int,M>) const {
return _size.current() / _size.subindex().current();
}
inline int count_size(std::integral_constant<int,1>) const {
return _size.current();
}
Call *_data;
multi_size_wrap<N> _size;
};
template <typename Call>
class table_data_wrap<Call, 0> {
public:
inline table_data_wrap(Call *data, multi_size_wrap<0> size) : _data(data) {
}
inline Call &operator[](multi_index_wrap<0> index) const {
return *_data;
}
private:
Call *_data;
};
template <typename Call, int N>
class table_data_wrap;
template <typename Arg, typename ...Args>
struct table_count_size<Arg, Args...> {
static constexpr int N = sizeof...(Args) + 1;
static inline void call(multi_size_wrap<N> index) {
auto subindex = index.subindex();
table_count_size<Args...>::call(subindex);
index.current() = count(is_virtual_argument<Arg>()) * subindex.current();
}
static inline int count(std::integral_constant<bool, false>) {
return 1;
}
static inline int count(std::integral_constant<bool, true>) {
return base::type_traits<Arg>::pointed_type::virtual_object_get_child_entries().size();
}
};
template <>
struct table_count_size<> {
static inline void call(multi_size_wrap<0> index) {
}
};
template <typename Call, int N>
class table_data {
public:
inline table_data_wrap<Call, N> data_wrap() {
return table_data_wrap<Call, N>(_data.data(), _size.data_wrap());
}
inline Call &operator[](multi_index<N> index) {
int flat_index = 0;
for (int i = 0; i != N - 1; ++i) {
flat_index += _size.value(i + 1) * index.value(i);
}
flat_index += index.value(N - 1);
return _data[flat_index];
}
template <typename ...Args>
inline bool changed() {
if (!_data.empty()) {
return false;
}
multi_size<N> size;
table_count_size<Args...>::call(size.data_wrap());
_size = size;
_data.resize(_size.value(0), nullptr);
return true;
}
private:
std::vector<Call> _data;
multi_size<N> _size;
};
template <typename Call>
class table_data<Call, 0> {
public:
inline table_data_wrap<Call, 0> data_wrap() {
return table_data_wrap<Call, 0>(&_call, multi_size_wrap<0>(nullptr));
}
inline Call &operator[](multi_index<0> index) {
return _call;
}
inline bool changed() const {
return false;
}
private:
Call _call = nullptr;
};
template <typename Call, typename ...Args>
struct table_fill_entry_helper;
template <typename Call, typename Arg, typename ...Args>
struct table_fill_entry_helper<Call, Arg, Args...> {
static constexpr int N = sizeof...(Args) + 1;
static inline bool call(table_data_wrap<Call, N> table, multi_index_wrap<N> index, Call &fill) {
auto start = index.current();
for (auto i = start, count = table.size(); i != count; ++i) {
auto foundGoodType = good(is_virtual_argument<Arg>(), start, index.current());
if (foundGoodType) {
index.current() = i;
if (table_fill_entry_helper<Call, Args...>::call(table[i], index.subindex(), fill)) {
return true;
}
}
}
index.current() = start;
return false;
}
static inline bool good(std::integral_constant<bool,false>, int start, int current) {
return (start == current);
}
static inline bool good(std::integral_constant<bool,true>, int start, int current) {
using BaseObject = typename base::type_traits<Arg>::pointed_type;
auto &entries = BaseObject::virtual_object_get_child_entries();
return (start == current) || entries[start].check_is_parent(entries[current]);
}
};
template <typename Call>
struct table_fill_entry_helper<Call> {
static inline bool call(table_data_wrap<Call, 0> table, multi_index_wrap<0> index, Call &fill) {
if (auto overrideMethod = table[index]) {
fill = overrideMethod;
return true;
}
return false;
}
};
template <typename Call, int N>
struct table_fill_entry;
template <typename ReturnType, int N, typename BaseMethod, typename ...Args>
struct table_fill_entry<ReturnType(*)(BaseMethod*, Args...), N> {
using Call = ReturnType(*)(BaseMethod*, Args...);
static inline void call(table_data_wrap<Call, N> table, multi_index_wrap<N> index, Call &fill) {
table_fill_entry_helper<Call, Args...>::call(table, index, fill);
}
};
template <typename Call, int N>
inline void fill_entry(table_data_wrap<Call, N> table, multi_index_wrap<N> index, Call &fill) {
return virtual_methods::table_fill_entry<Call, N>::call(table, index, fill);
}
template <int M, typename ...ConcreteArgs>
struct override_key_collector_helper;
template <int M, typename ConcreteArg, typename ...ConcreteArgs>
struct override_key_collector_helper<M, ConcreteArg, ConcreteArgs...> {
static inline void call(int **indices) {
setValue(is_virtual_argument<ConcreteArg>(), indices);
override_key_collector_helper<M + 1, ConcreteArgs...>::call(indices);
}
static inline void setValue(std::integral_constant<bool,false>, int **indices) {
indices[M] = nullptr;
}
static inline void setValue(std::integral_constant<bool,true>, int **indices) {
using ConcreteObject = typename base::type_traits<ConcreteArg>::pointed_type;
using IsParentCheckStruct = is_parent<ConcreteObject>;
using IsParentCheckPointer = decltype(&IsParentCheckStruct::check);
using override_key_collector_dont_optimize_away = dont_optimize_away_struct<IsParentCheckPointer, &IsParentCheckStruct::check>;
override_key_collector_dont_optimize_away dont_optimize_away_object;
(void)dont_optimize_away_object;
// Check that is_parent<> can be instantiated.
// So every ConcreteObject is a valid child of virtual_object<>.
dont_optimize_away(reinterpret_cast<void*>(&IsParentCheckStruct::check));
indices[M] = &ConcreteObject::virtual_object_child_index_static();
}
};
template <int M>
struct override_key_collector_helper<M> {
static inline void call(int **indices) {
}
};
template <typename CallSignature>
struct override_key_collector;
template <typename ReturnType, typename BaseMethod, typename ...ConcreteArgs>
struct override_key_collector<ReturnType(*)(BaseMethod, ConcreteArgs...)> {
static inline void call(int **indices) {
override_key_collector_helper<0, ConcreteArgs...>::call(indices);
}
};
template <int N>
class override_key {
public:
inline multi_index<N> value() const {
multi_index<N> result;
for (int i = 0; i != N; ++i) {
auto pointer = _indices[i];
result._indices[i] = (pointer ? *pointer : 0);
}
return result;
}
friend inline bool operator<(const override_key &k1, const override_key &k2) {
for (int i = 0; i != N; ++i) {
auto pointer1 = k1._indices[i], pointer2 = k2._indices[i];
if (pointer1 < pointer2) {
return true;
} else if (pointer1 > pointer2) {
return false;
}
}
return false;
}
template <typename CallSignature>
inline void collect() {
override_key_collector<CallSignature>::call(_indices);
}
private:
int *_indices[N];
};
template <typename BaseMethod, typename ConcreteMethod, typename CallSignature, typename ...Args>
struct static_cast_helper;
template <typename BaseMethod, typename ConcreteMethod, typename ReturnType, typename ...ConcreteArgs, typename ...Args>
struct static_cast_helper<BaseMethod, ConcreteMethod, ReturnType(*)(BaseMethod *, ConcreteArgs...), Args...> {
static inline ReturnType call(BaseMethod *context, Args ...args) {
return ConcreteMethod::call(context, static_cast<ConcreteArgs>(args)...);
}
};
} // namespace virtual_methods
// This is a base class for all your virtual methods.
// It dispatches a call to one of the registered virtual_overrides
// or calls the fallback method of the BaseMethod class.
template <typename BaseMethod, typename ReturnType, typename ...Args>
class virtual_method {
static constexpr int N = sizeof...(Args);
using virtual_method_call = ReturnType(*)(BaseMethod *context, Args... args);
public:
inline ReturnType call(Args... args) {
auto context = static_cast<BaseMethod*>(this);
auto index = virtual_methods::multi_index<N>::collect(args...);
auto &table = virtual_method_prepare_table();
auto &entry = table[index];
if (!entry) {
virtual_methods::fill_entry(table.data_wrap(), index.data_wrap(), entry);
if (!entry) {
entry = &virtual_method::virtual_method_base_instance;
}
}
return (*entry)(context, args...);
}
private:
// This map of methods contains only the original registered overrides.
using virtual_method_override_key = virtual_methods::override_key<N>;
using virtual_method_override_map = std::map<virtual_method_override_key, virtual_method_call>;
static inline virtual_method_override_map &virtual_method_get_override_map() {
static virtual_method_override_map override_map;
return override_map;
}
// This method generates and returns a virtual table which holds a method
// for any child in the hierarchy or nullptr if none of the virtual_overrides fit.
using virtual_method_table_data = virtual_methods::table_data<virtual_method_call, N>;
static inline virtual_method_table_data &virtual_method_get_table_data() {
static virtual_method_table_data virtual_table;
return virtual_table;
}
static inline virtual_method_table_data &virtual_method_prepare_table() {
auto &virtual_table = virtual_method_get_table_data();
if (virtual_table.template changed<Args...>()) {
virtual_methods::first_dispatch_fired(true);
// The class hierarchy has changed - we need to generate the virtual table once again.
// All other handlers will be placed if they're called.
for (auto &i : virtual_method_get_override_map()) {
virtual_table[i.first.value()] = i.second;
}
}
return virtual_table;
}
static ReturnType virtual_method_base_instance(BaseMethod *context, Args... args) {
return BaseMethod::default_call(context, args...);
}
template <typename ConcreteMethod>
static ReturnType virtual_method_override_instance(BaseMethod *context, Args... args) {
return virtual_methods::static_cast_helper<BaseMethod, ConcreteMethod, decltype(&ConcreteMethod::call), Args...>::call(context, args...);
}
template <typename ConcreteMethod>
static inline void virtual_method_register_override() {
auto call = &virtual_method_override_instance<ConcreteMethod>;
virtual_methods::override_key<N> key;
key.template collect<decltype(&ConcreteMethod::call)>();
virtual_method_get_override_map()[key] = call;
}
template <typename ConcreteMethod, typename OtherBaseMethod>
friend class virtual_override;
};
template <typename ConcreteMethod, typename BaseMethod>
class virtual_override {
protected:
virtual ~virtual_override() {
virtual_methods::dont_optimize_away(&_virtual_override_registrator);
}
private:
class virtual_override_registrator {
public:
inline virtual_override_registrator() {
Assert(!virtual_methods::first_dispatch_fired());
BaseMethod::template virtual_method_register_override<ConcreteMethod>();
}
};
static virtual_override_registrator _virtual_override_registrator;
using virtual_override_dont_optimize_away_registrator = virtual_methods::dont_optimize_away_struct<virtual_override_registrator*, &_virtual_override_registrator>;
};
template <typename ConcreteMethod, typename BaseMethod>
typename virtual_override<ConcreteMethod, BaseMethod>::virtual_override_registrator virtual_override<ConcreteMethod, BaseMethod>::_virtual_override_registrator = {};
} // namespace base

45
Telegram/SourceFiles/platform/mac/mac_iconv_helper.c
View File

@ -1,45 +0,0 @@
/*
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
*/
#include <iconv.h>
#ifdef iconv_open
#undef iconv_open
#endif // iconv_open
#ifdef iconv
#undef iconv
#endif // iconv
#ifdef iconv_close
#undef iconv_close
#endif // iconv_close
iconv_t iconv_open(const char* tocode, const char* fromcode) {
return libiconv_open(tocode, fromcode);
}
size_t iconv(iconv_t cd, char** inbuf, size_t *inbytesleft, char** outbuf, size_t *outbytesleft) {
return libiconv(cd, inbuf, inbytesleft, outbuf, outbytesleft);
}
int iconv_close(iconv_t cd) {
return libiconv_close(cd);
}

165
Telegram/gyp/PrecompiledHeader.cmake
View File

@ -1,165 +0,0 @@
##
## Modified for Telegram Desktop project by Telegram Desktop authors.
##
# Function for setting up precompiled headers. Usage:
#
# add_library/executable(target
# pchheader.c pchheader.cpp pchheader.h)
#
# add_precompiled_header(target pchheader.h
# [FORCEINCLUDE]
# [SOURCE_C pchheader.c]
# [SOURCE_CXX pchheader.cpp])
#
# Options:
#
# FORCEINCLUDE: Add compiler flags to automatically include the
# pchheader.h from every source file. Works with both GCC and
# MSVC. This is recommended.
#
# SOURCE_C/CXX: Specifies the .c/.cpp source file that includes
# pchheader.h for generating the pre-compiled header
# output. Defaults to pchheader.c. Only required for MSVC.
#
# Caveats:
#
# * Its not currently possible to use the same precompiled-header in
# more than a single target in the same directory (No way to set
# the source file properties differently for each target).
#
# * MSVC: A source file with the same name as the header must exist
# and be included in the target (E.g. header.cpp). Name of file
# can be changed using the SOURCE_CXX/SOURCE_C options.
#
# License:
#
# Copyright (C) 2009-2013 Lars Christensen <larsch@belunktum.dk>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the 'Software') deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
include(CMakeParseArguments)
macro(combine_arguments _variable)
set(_result "")
foreach(_element ${${_variable}})
set(_result "${_result} \"${_element}\"")
endforeach()
string(STRIP "${_result}" _result)
set(${_variable} "${_result}")
endmacro()
function(export_all_flags _filename _source_name_for_flags)
set(_include_directories "$<TARGET_PROPERTY:${_target},INCLUDE_DIRECTORIES>")
set(_compile_definitions "$<TARGET_PROPERTY:${_target},COMPILE_DEFINITIONS>")
get_source_file_property(_compile_flags "${_source_name_for_flags}" COMPILE_FLAGS)
set(_compile_options "$<TARGET_PROPERTY:${_target},COMPILE_OPTIONS>")
set(_include_directories "$<$<BOOL:${_include_directories}>:-I$<JOIN:${_include_directories},\n-I>\n>")
set(_compile_definitions "$<$<BOOL:${_compile_definitions}>:-D$<JOIN:${_compile_definitions},\n-D>\n>")
set(_compile_flags "$<$<BOOL:${_compile_flags}>:$<JOIN:${_compile_flags},\n>\n>")
set(_compile_options "$<$<BOOL:${_compile_options}>:$<JOIN:${_compile_options},\n>\n>")
file(GENERATE OUTPUT "${_filename}" CONTENT "${_compile_definitions}${_include_directories}${_compile_flags}${_compile_options}\n")
endfunction()
function(add_precompiled_header _target _input)
if(CMAKE_COMPILER_IS_GNUCXX)
get_filename_component(_name ${_input} NAME)
set(_pch_header "${CMAKE_CURRENT_SOURCE_DIR}/${_input}")
set(_pch_binary_dir "${CMAKE_CURRENT_BINARY_DIR}/${_target}_pch")
set(_pchfile "${_pch_binary_dir}/${_name}")
set(_outdir "${_pch_binary_dir}/${_name}.gch")
make_directory(${_outdir})
set(_output_cxx "${_outdir}/.c++")
set(_output_c "${_outdir}/.c")
get_property(_sources TARGET ${_target} PROPERTY SOURCES)
foreach(_source ${_sources})
if(_source MATCHES \\.\(c\)$ AND NOT _source_for_c_flags)
set(_source_for_c_flags "${_source}")
elseif(_source MATCHES \\.\(cc|cxx|cpp\)$ AND NOT _source_for_cpp_flags)
set(_source_for_cpp_flags "${_source}")
endif()
endforeach()
add_custom_command(
OUTPUT "${_pchfile}"
COMMAND "${CMAKE_COMMAND}" -E copy "${_pch_header}" "${_pchfile}"
DEPENDS "${_pch_header}"
IMPLICIT_DEPENDS CXX "${_pch_header}"
IMPLICIT_DEPENDS C "${_pch_header}"
COMMENT "Updating ${_name}")
if(_source_for_c_flags)
set(_pch_c_flags_file "${_pch_binary_dir}/compile_flags_c.rsp")
export_all_flags("${_pch_c_flags_file}" "${_source_for_c_flags}")
set(_compiler_FLAGS "@${_pch_c_flags_file}")
add_custom_command(
OUTPUT "${_output_c}"
COMMAND "${CMAKE_C_COMPILER}" ${_compiler_FLAGS} -x c-header -o "${_output_c}" -c "${_pchfile}"
DEPENDS "${_pchfile}" "${_pch_c_flags_file}"
IMPLICIT_DEPENDS C "${_pch_header}"
COMMENT "Precompiling ${_name} for ${_target} (C)")
endif()
if(_source_for_cpp_flags)
set(_pch_cpp_flags_file "${_pch_binary_dir}/compile_flags_cpp.rsp")
export_all_flags("${_pch_cpp_flags_file}" "${_source_for_cpp_flags}")
set(_compiler_FLAGS "@${_pch_cpp_flags_file}")
add_custom_command(
OUTPUT "${_output_cxx}"
COMMAND "${CMAKE_CXX_COMPILER}" ${_compiler_FLAGS} -x c++-header -o "${_output_cxx}" -c "${_pchfile}"
DEPENDS "${_pchfile}" "${_pch_cpp_flags_file}"
IMPLICIT_DEPENDS CXX "${_pch_header}"
COMMENT "Precompiling ${_name} for ${_target} (C++)")
endif()
foreach(_source ${_sources})
set(_pch_compile_flags "")
if(_source MATCHES \\.\(cc|cxx|cpp|c\)$)
get_source_file_property(_pch_compile_flags "${_source}" COMPILE_FLAGS)
if(NOT _pch_compile_flags)
set(_pch_compile_flags)
endif()
separate_arguments(_pch_compile_flags)
if(_source MATCHES \\.\(cc|cxx|cpp\)$)
list(APPEND _pch_compile_flags -include "${_pchfile}")
else()
list(APPEND _pch_compile_flags "-I${_pch_binary_dir}")
endif()
get_source_file_property(_object_depends "${_source}" OBJECT_DEPENDS)
if(NOT _object_depends)
set(_object_depends)
endif()
list(APPEND _object_depends "${_pchfile}")
if(_source MATCHES \\.\(cc|cxx|cpp\)$)
list(APPEND _object_depends "${_output_cxx}")
else()
list(APPEND _object_depends "${_output_c}")
endif()
combine_arguments(_pch_compile_flags)
set_source_files_properties(${_source} PROPERTIES
COMPILE_FLAGS "${_pch_compile_flags}"
OBJECT_DEPENDS "${_object_depends}")
endif()
endforeach()
endif(CMAKE_COMPILER_IS_GNUCXX)
endfunction()

130
Telegram/gyp/Telegram.gyp
View File

@ -1,130 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'common.gypi',
],
'targets': [{
'target_name': 'Telegram',
'variables': {
'variables': {
'libs_loc': '../../../Libraries',
},
'libs_loc': '<(libs_loc)',
'src_loc': '../SourceFiles',
'res_loc': '../Resources',
'submodules_loc': '../ThirdParty',
'minizip_loc': '<(submodules_loc)/minizip',
'sp_media_key_tap_loc': '<(submodules_loc)/SPMediaKeyTap',
'emoji_suggestions_loc': '<(submodules_loc)/emoji_suggestions',
'style_files': [
'<(res_loc)/colors.palette',
'<(res_loc)/basic.style',
'<(src_loc)/boxes/boxes.style',
'<(src_loc)/calls/calls.style',
'<(src_loc)/dialogs/dialogs.style',
'<(src_loc)/history/history.style',
'<(src_loc)/intro/intro.style',
'<(src_loc)/media/view/mediaview.style',
'<(src_loc)/media/player/media_player.style',
'<(src_loc)/overview/overview.style',
'<(src_loc)/profile/profile.style',
'<(src_loc)/settings/settings.style',
'<(src_loc)/chat_helpers/chat_helpers.style',
'<(src_loc)/ui/widgets/widgets.style',
'<(src_loc)/window/window.style',
],
'langpacks': [
'en',
'de',
'es',
'it',
'nl',
'ko',
'pt-BR',
],
'build_defines%': '',
'list_sources_command': 'python <(DEPTH)/list_sources.py --input <(DEPTH)/telegram_sources.txt --replace src_loc=<(src_loc)',
},
'includes': [
'common_executable.gypi',
'telegram_qrc.gypi',
'telegram_win.gypi',
'telegram_mac.gypi',
'telegram_linux.gypi',
'qt.gypi',
'qt_moc.gypi',
'qt_rcc.gypi',
'codegen_rules.gypi',
],
'dependencies': [
'codegen.gyp:codegen_emoji',
'codegen.gyp:codegen_lang',
'codegen.gyp:codegen_numbers',
'codegen.gyp:codegen_style',
'tests/tests.gyp:tests',
'utils.gyp:Updater',
'../ThirdParty/libtgvoip/libtgvoip.gyp:libtgvoip',
],
'defines': [
'AL_LIBTYPE_STATIC',
'AL_ALEXT_PROTOTYPES',
'TGVOIP_USE_CXX11_LIB',
'<!@(python -c "for s in \'<(build_defines)\'.split(\',\'): print(s)")',
],
'include_dirs': [
'<(src_loc)',
'<(SHARED_INTERMEDIATE_DIR)',
'<(libs_loc)/breakpad/src',
'<(libs_loc)/lzma/C',
'<(libs_loc)/libexif-0.6.20',
'<(libs_loc)/zlib',
'<(libs_loc)/ffmpeg',
'<(libs_loc)/openal-soft/include',
'<(libs_loc)/opus/include',
'<(minizip_loc)',
'<(sp_media_key_tap_loc)',
'<(emoji_suggestions_loc)',
'<(submodules_loc)/GSL/include',
'<(submodules_loc)/variant/include',
],
'sources': [
'<@(qrc_files)',
'<@(style_files)',
'<!@(<(list_sources_command) <(qt_moc_list_sources_arg))',
],
'sources!': [
'<!@(<(list_sources_command) <(qt_moc_list_sources_arg) --exclude_for <(build_os))',
],
'conditions': [
[ '"<(official_build_target)" != ""', {
'defines': [
'CUSTOM_API_ID',
],
'dependencies': [
'utils.gyp:Packer',
],
}],
],
}],
}

169
Telegram/gyp/codegen.gyp
View File

@ -1,169 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'common.gypi',
],
'targets': [{
'target_name': 'codegen_lang',
'variables': {
'src_loc': '../SourceFiles',
'mac_target': '10.10',
},
'includes': [
'common_executable.gypi',
'qt.gypi',
],
'include_dirs': [
'<(src_loc)',
],
'sources': [
'<(src_loc)/codegen/common/basic_tokenized_file.cpp',
'<(src_loc)/codegen/common/basic_tokenized_file.h',
'<(src_loc)/codegen/common/checked_utf8_string.cpp',
'<(src_loc)/codegen/common/checked_utf8_string.h',
'<(src_loc)/codegen/common/clean_file.cpp',
'<(src_loc)/codegen/common/clean_file.h',
'<(src_loc)/codegen/common/clean_file_reader.h',
'<(src_loc)/codegen/common/const_utf8_string.h',
'<(src_loc)/codegen/common/cpp_file.cpp',
'<(src_loc)/codegen/common/cpp_file.h',
'<(src_loc)/codegen/common/logging.cpp',
'<(src_loc)/codegen/common/logging.h',
'<(src_loc)/codegen/lang/generator.cpp',
'<(src_loc)/codegen/lang/generator.h',
'<(src_loc)/codegen/lang/main.cpp',
'<(src_loc)/codegen/lang/options.cpp',
'<(src_loc)/codegen/lang/options.h',
'<(src_loc)/codegen/lang/parsed_file.cpp',
'<(src_loc)/codegen/lang/parsed_file.h',
'<(src_loc)/codegen/lang/processor.cpp',
'<(src_loc)/codegen/lang/processor.h',
],
}, {
'target_name': 'codegen_style',
'variables': {
'src_loc': '../SourceFiles',
'mac_target': '10.10',
},
'includes': [
'common_executable.gypi',
'qt.gypi',
],
'include_dirs': [
'<(src_loc)',
],
'sources': [
'<(src_loc)/codegen/common/basic_tokenized_file.cpp',
'<(src_loc)/codegen/common/basic_tokenized_file.h',
'<(src_loc)/codegen/common/checked_utf8_string.cpp',
'<(src_loc)/codegen/common/checked_utf8_string.h',
'<(src_loc)/codegen/common/clean_file.cpp',
'<(src_loc)/codegen/common/clean_file.h',
'<(src_loc)/codegen/common/clean_file_reader.h',
'<(src_loc)/codegen/common/const_utf8_string.h',
'<(src_loc)/codegen/common/cpp_file.cpp',
'<(src_loc)/codegen/common/cpp_file.h',
'<(src_loc)/codegen/common/logging.cpp',
'<(src_loc)/codegen/common/logging.h',
'<(src_loc)/codegen/style/generator.cpp',
'<(src_loc)/codegen/style/generator.h',
'<(src_loc)/codegen/style/main.cpp',
'<(src_loc)/codegen/style/module.cpp',
'<(src_loc)/codegen/style/module.h',
'<(src_loc)/codegen/style/options.cpp',
'<(src_loc)/codegen/style/options.h',
'<(src_loc)/codegen/style/parsed_file.cpp',
'<(src_loc)/codegen/style/parsed_file.h',
'<(src_loc)/codegen/style/processor.cpp',
'<(src_loc)/codegen/style/processor.h',
'<(src_loc)/codegen/style/structure_types.cpp',
'<(src_loc)/codegen/style/structure_types.h',
],
}, {
'target_name': 'codegen_numbers',
'variables': {
'src_loc': '../SourceFiles',
'mac_target': '10.10',
},
'includes': [
'common_executable.gypi',
'qt.gypi',
],
'include_dirs': [
'<(src_loc)',
],
'sources': [
'<(src_loc)/codegen/common/basic_tokenized_file.cpp',
'<(src_loc)/codegen/common/basic_tokenized_file.h',
'<(src_loc)/codegen/common/checked_utf8_string.cpp',
'<(src_loc)/codegen/common/checked_utf8_string.h',
'<(src_loc)/codegen/common/clean_file.cpp',
'<(src_loc)/codegen/common/clean_file.h',
'<(src_loc)/codegen/common/clean_file_reader.h',
'<(src_loc)/codegen/common/const_utf8_string.h',
'<(src_loc)/codegen/common/cpp_file.cpp',
'<(src_loc)/codegen/common/cpp_file.h',
'<(src_loc)/codegen/common/logging.cpp',
'<(src_loc)/codegen/common/logging.h',
'<(src_loc)/codegen/numbers/generator.cpp',
'<(src_loc)/codegen/numbers/generator.h',
'<(src_loc)/codegen/numbers/main.cpp',
'<(src_loc)/codegen/numbers/options.cpp',
'<(src_loc)/codegen/numbers/options.h',
'<(src_loc)/codegen/numbers/parsed_file.cpp',
'<(src_loc)/codegen/numbers/parsed_file.h',
'<(src_loc)/codegen/numbers/processor.cpp',
'<(src_loc)/codegen/numbers/processor.h',
],
}, {
'target_name': 'codegen_emoji',
'variables': {
'src_loc': '../SourceFiles',
'mac_target': '10.10',
},
'includes': [
'common_executable.gypi',
'qt.gypi',
],
'include_dirs': [
'<(src_loc)',
],
'sources': [
'<(src_loc)/codegen/common/cpp_file.cpp',
'<(src_loc)/codegen/common/cpp_file.h',
'<(src_loc)/codegen/common/logging.cpp',
'<(src_loc)/codegen/common/logging.h',
'<(src_loc)/codegen/emoji/data.cpp',
'<(src_loc)/codegen/emoji/data.h',
'<(src_loc)/codegen/emoji/generator.cpp',
'<(src_loc)/codegen/emoji/generator.h',
'<(src_loc)/codegen/emoji/main.cpp',
'<(src_loc)/codegen/emoji/options.cpp',
'<(src_loc)/codegen/emoji/options.h',
'<(src_loc)/codegen/emoji/replaces.cpp',
'<(src_loc)/codegen/emoji/replaces.h',
],
}],
}

178
Telegram/gyp/codegen_rules.gypi
View File

@ -1,178 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'actions': [{
'action_name': 'update_dependent_styles',
'inputs': [
'<(DEPTH)/update_dependent.py',
'<@(style_files)',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/update_dependent_styles.timestamp',
],
'action': [
'python', '<(DEPTH)/update_dependent.py', '--styles',
'-I', '<(res_loc)', '-I', '<(src_loc)',
'-o', '<(SHARED_INTERMEDIATE_DIR)/update_dependent_styles.timestamp',
'<@(style_files)',
],
'message': 'Updating dependent style files..',
}, {
'action_name': 'update_dependent_qrc',
'inputs': [
'<(DEPTH)/update_dependent.py',
'<@(qrc_files)',
'<!@(python <(DEPTH)/update_dependent.py --qrc_list <@(qrc_files))',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/update_dependent_qrc.timestamp',
],
'action': [
'python', '<(DEPTH)/update_dependent.py', '--qrc',
'-o', '<(SHARED_INTERMEDIATE_DIR)/update_dependent_qrc.timestamp',
'<@(qrc_files)',
],
'message': 'Updating dependent qrc files..',
}, {
'action_name': 'codegen_palette',
'inputs': [
'<(PRODUCT_DIR)/codegen_style<(exe_ext)',
'<(SHARED_INTERMEDIATE_DIR)/update_dependent_styles.timestamp',
'<(res_loc)/colors.palette',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/styles/palette.h',
'<(SHARED_INTERMEDIATE_DIR)/styles/palette.cpp',
],
'action': [
'<(PRODUCT_DIR)/codegen_style<(exe_ext)',
'-I', '<(res_loc)', '-I', '<(src_loc)',
'-o', '<(SHARED_INTERMEDIATE_DIR)/styles',
'-w', '<(PRODUCT_DIR)/..',
# GYP/Ninja bug workaround: if we specify just <(RULE_INPUT_PATH)
# the <(RULE_INPUT_ROOT) variables won't be available in Ninja,
# and the 'message' will be just 'codegen_style-ing .style..'
# Looks like the using the <(RULE_INPUT_ROOT) here "exports" it
# for using in the 'message' field.
'<(res_loc)/colors.palette',
],
'message': 'codegen_palette-ing colors..',
'process_outputs_as_sources': 1,
}, {
'action_name': 'codegen_lang',
'inputs': [
'<(PRODUCT_DIR)/codegen_lang<(exe_ext)',
'<(res_loc)/langs/lang.strings',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/lang_auto.cpp',
'<(SHARED_INTERMEDIATE_DIR)/lang_auto.h',
],
'action': [
'<(PRODUCT_DIR)/codegen_lang<(exe_ext)',
'-o', '<(SHARED_INTERMEDIATE_DIR)', '<(res_loc)/langs/lang.strings',
'-w', '<(PRODUCT_DIR)/..',
],
'message': 'codegen_lang-ing lang.strings..',
'process_outputs_as_sources': 1,
}, {
'action_name': 'codegen_numbers',
'inputs': [
'<(PRODUCT_DIR)/codegen_numbers<(exe_ext)',
'<(res_loc)/numbers.txt',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/numbers.cpp',
'<(SHARED_INTERMEDIATE_DIR)/numbers.h',
],
'action': [
'<(PRODUCT_DIR)/codegen_numbers<(exe_ext)',
'-o', '<(SHARED_INTERMEDIATE_DIR)', '<(res_loc)/numbers.txt',
'-w', '<(PRODUCT_DIR)/..',
],
'message': 'codegen_numbers-ing numbers.txt..',
'process_outputs_as_sources': 1,
}, {
'action_name': 'codegen_scheme',
'inputs': [
'<(src_loc)/codegen/scheme/codegen_scheme.py',
'<(res_loc)/scheme.tl',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/scheme.cpp',
'<(SHARED_INTERMEDIATE_DIR)/scheme.h',
],
'action': [
'python', '<(src_loc)/codegen/scheme/codegen_scheme.py',
'-o', '<(SHARED_INTERMEDIATE_DIR)', '<(res_loc)/scheme.tl',
],
'message': 'codegen_scheme-ing scheme.tl..',
'process_outputs_as_sources': 1,
}, {
'action_name': 'codegen_emoji',
'inputs': [
'<(PRODUCT_DIR)/codegen_emoji<(exe_ext)',
'<(res_loc)/emoji_autocomplete.json',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/emoji.cpp',
'<(SHARED_INTERMEDIATE_DIR)/emoji.h',
'<(SHARED_INTERMEDIATE_DIR)/emoji_suggestions_data.cpp',
'<(SHARED_INTERMEDIATE_DIR)/emoji_suggestions_data.h',
],
'action': [
'<(PRODUCT_DIR)/codegen_emoji<(exe_ext)',
'<(res_loc)/emoji_autocomplete.json',
'-o', '<(SHARED_INTERMEDIATE_DIR)',
],
'message': 'codegen_emoji-ing..',
'process_outputs_as_sources': 1,
}],
'rules': [{
'rule_name': 'codegen_style',
'extension': 'style',
'inputs': [
'<(PRODUCT_DIR)/codegen_style<(exe_ext)',
'<(SHARED_INTERMEDIATE_DIR)/update_dependent_styles.timestamp',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/styles/style_<(RULE_INPUT_ROOT).h',
'<(SHARED_INTERMEDIATE_DIR)/styles/style_<(RULE_INPUT_ROOT).cpp',
],
'action': [
'<(PRODUCT_DIR)/codegen_style<(exe_ext)',
'-I', '<(res_loc)', '-I', '<(src_loc)',
'-o', '<(SHARED_INTERMEDIATE_DIR)/styles',
'-w', '<(PRODUCT_DIR)/..',
# GYP/Ninja bug workaround: if we specify just <(RULE_INPUT_PATH)
# the <(RULE_INPUT_ROOT) variables won't be available in Ninja,
# and the 'message' will be just 'codegen_style-ing .style..'
# Looks like the using the <(RULE_INPUT_ROOT) here "exports" it
# for using in the 'message' field.
'<(RULE_INPUT_DIRNAME)/<(RULE_INPUT_ROOT)<(RULE_INPUT_EXT)',
],
'message': 'codegen_style-ing <(RULE_INPUT_ROOT).style..',
'process_outputs_as_sources': 1,
}],
}

121
Telegram/gyp/common.gypi
View File

@ -1,121 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'settings_win.gypi',
'settings_mac.gypi',
'settings_linux.gypi',
],
'variables': {
'variables': {
'variables': {
'variables': {
'variables': {
'build_os%': '<(OS)',
},
'build_os%': '<(build_os)',
'conditions': [
[ 'build_os == "win"', {
'build_win': 1,
}, {
'build_win': 0,
}],
[ 'build_os == "mac"', {
'build_mac': 1,
}, {
'build_mac': 0,
}],
[ 'build_os == "linux"', {
'build_linux': 1,
}, {
'build_linux': 0,
}],
],
},
'build_os%': '<(build_os)',
'build_win%': '<(build_win)',
'build_mac%': '<(build_mac)',
'build_linux%': '<(build_linux)',
},
'build_os%': '<(build_os)',
'build_win%': '<(build_win)',
'build_mac%': '<(build_mac)',
'build_linux%': '<(build_linux)',
'official_build_target%': '',
},
'build_os%': '<(build_os)',
'build_win%': '<(build_win)',
'build_mac%': '<(build_mac)',
'build_linux%': '<(build_linux)',
'official_build_target%': '<(official_build_target)',
# GYP does not support per-configuration libraries :(
# So they will be emulated through additional link flags,
# which will contain <(ld_lib_prefix)LibraryName<(ld_lib_postfix)
'conditions': [
[ 'build_win', {
'ld_lib_prefix': '',
'ld_lib_postfix': '.lib',
'exe_ext': '.exe',
}, {
'ld_lib_prefix': '-l',
'ld_lib_postfix': '',
'exe_ext': '',
}],
[ '"<(official_build_target)" == "mac32"', {
'mac_target%': '10.6',
'build_macold': 1,
}, {
'mac_target%': '10.8',
'build_macold': 0,
}],
[ '"<(official_build_target)" == "macstore"', {
'build_macstore': 1,
}, {
'build_macstore': 0,
}],
[ '"<(official_build_target)" == "uwp"', {
'build_uwp': 1,
}, {
'build_uwp': 0,
}],
],
'ld_lib_prefix': '<(ld_lib_prefix)',
'ld_lib_postfix': '<(ld_lib_postfix)',
'exe_ext': '<(exe_ext)',
'library%': 'static_library',
},
'configurations': {
'Debug': {
'defines': [
'_DEBUG',
],
},
'Release': {
'defines': [
'NDEBUG',
],
},
},
}

34
Telegram/gyp/common_executable.gypi
View File

@ -1,34 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'type': 'executable',
'variables': {
'win_subsystem': '2', # Windows application
},
'includes': [
'common.gypi',
],
'msvs_settings': {
'VCLinkerTool': {
'SubSystem': '<(win_subsystem)',
'ImportLibrary': '<(PRODUCT_DIR)/<(_target_name).lib',
},
},
}

57
Telegram/gyp/create_env.py
View File

@ -1,57 +0,0 @@
'''
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014 John Preston, https://desktop.telegram.org
'''
import glob
import re
import os
# Generate custom environment.x86 for ninja
# We use msbuild.log to extract some variables
variables = [
'TMP',
'SYSTEMROOT',
'TEMP',
'LIB',
'LIBPATH',
'PATH',
'PATHEXT',
'INCLUDE',
]
var_values = {}
for var_name in variables:
var_values[var_name] = os.environ[var_name]
next_contains_var = 0
with open('msbuild.log') as f:
for line in f:
if (re.match(r'^\s*Task "SetEnv"\s*$', line)):
next_contains_var = 1
elif next_contains_var:
cleanline = re.sub(r'^\s*|\s*$', '', line)
name_value_pair = re.match(r'^([A-Z]+)=(.+)$', cleanline)
if name_value_pair:
var_values[name_value_pair.group(1)] = name_value_pair.group(2)
next_contains_var = 0
out = open('environment.x86', 'wb')
for var_name in variables:
out.write(var_name + '=' + var_values[var_name] + '\0')
out.write('\0')
out.close()

162
Telegram/gyp/list_sources.py
View File

@ -1,162 +0,0 @@
'''
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014 John Preston, https://desktop.telegram.org
'''
from __future__ import print_function
import sys
import os
import re
import time
import codecs
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
sys.exit(1)
def check_non_empty_moc(file_path):
if not os.path.isfile(file_path):
return False
if re.search(r'\.h$', file_path):
with codecs.open(file_path, mode="r", encoding="utf-8") as f:
for line in f:
if re.search(r'(^|\s)Q_OBJECT(\s|$)', line):
return True
return False
def should_exclude(rules, exclude_for):
for rule in rules:
if rule[0:1] == '!':
return (rule[1:] == exclude_for)
elif rule == exclude_for:
return False
return len(rules) > 0
my_path = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/')
file_paths = []
platform_rules = {}
next_input_path = 0
input_path = ''
next_moc_prefix = 0
moc_prefix = ''
next_replace = 0
replaces = []
next_exclude_for = 0
exclude_for = ''
next_self = 1
for arg in sys.argv:
if next_self != 0:
next_self = 0
continue
if arg == '--moc-prefix':
next_moc_prefix = 1
continue
elif next_moc_prefix == 1:
next_moc_prefix = 0
moc_prefix = arg.replace('SHARED_INTERMEDIATE_DIR', '<(SHARED_INTERMEDIATE_DIR)')
continue
if arg == '--input':
next_input_path = 1
continue
elif next_input_path == 1:
next_input_path = 0
input_path = arg
continue
if arg == '--replace':
next_replace = 1
continue
elif next_replace == 1:
next_replace = 0
replaces.append(arg)
continue
if arg == '--exclude_for':
next_exclude_for = 1
continue
elif next_exclude_for == 1:
next_exclude_for = 0
exclude_for = arg
continue
file_paths.append(arg)
if input_path != '':
if len(file_paths) != 0:
eprint('You need to specify input file or input paths in command line.')
elif not os.path.isfile(input_path):
eprint('Input path not found.')
else:
platforms = []
with open(input_path, 'r') as f:
for line in f:
file_path = line.strip()
if file_path[0:10] == 'platforms:':
platforms_list = file_path[10:].split(' ')
platforms = []
for platform in file_path[10:].split(' '):
platform = platform.strip()
if platform != '':
platforms.append(platform)
elif file_path[0:2] != '//' and file_path != '':
file_paths.append(file_path)
if len(platforms):
platform_rules[file_path] = platforms
elif '/platform/win/' in file_path:
platform_rules[file_path] = [ 'win' ]
elif '/platform/mac/' in file_path:
platform_rules[file_path] = [ 'mac' ]
elif '/platform/linux/' in file_path:
platform_rules[file_path] = [ 'linux' ]
for replace in replaces:
replace_parts = replace.split('=', 1)
if len(replace_parts) != 2:
eprint('Bad replace: ' + replace)
real_paths = []
real_platform_rules = {}
for file_path in file_paths:
real_path = file_path.replace('<(' + replace_parts[0] + ')', replace_parts[1])
real_paths.append(real_path)
if file_path in platform_rules:
real_platform_rules[real_path] = platform_rules[file_path]
file_paths = real_paths
platform_rules = real_platform_rules
if exclude_for != '':
real_paths = []
for file_path in file_paths:
if not file_path in platform_rules:
continue
if not should_exclude(platform_rules[file_path], exclude_for):
continue
real_paths.append(file_path)
file_paths = real_paths
for file_path in file_paths:
print(file_path)
if moc_prefix != '':
for file_path in file_paths:
if check_non_empty_moc(file_path):
m = re.search(r'(^|/)([^/]+)\.h$', file_path)
if not m:
eprint('Bad file path: ' + file_path)
print(moc_prefix + m.group(2) + '.cpp')

15
Telegram/gyp/print_version.sh
View File

@ -1,15 +0,0 @@
#!/usr/bin/env bash
set -e
FullExecPath=$PWD
pushd `dirname $0` > /dev/null
FullScriptPath=`pwd`
popd > /dev/null
while IFS='' read -r line || [[ -n "$line" ]]; do
set $line
eval $1="$2"
done < "$FullScriptPath/../build/version"
echo $AppVersionStr
exit

256
Telegram/gyp/qt.gypi
View File

@ -1,256 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'variables': {
'variables': {
'variables': {
'variables': {
'variables': {
'conditions': [
[ 'build_macold', {
'qt_version%': '5.3.2',
}, {
'qt_version%': '5.6.2',
}]
],
},
'qt_libs': [
'qwebp',
'Qt5PrintSupport',
'Qt5PlatformSupport',
'Qt5Network',
'Qt5Widgets',
'Qt5Gui',
'qtharfbuzzng',
],
'qt_version%': '<(qt_version)',
'conditions': [
[ 'build_macold', {
'linux_path_qt%': '/usr/local/macold/Qt-<(qt_version)',
}, {
'linux_path_qt%': '/usr/local/tdesktop/Qt-<(qt_version)',
}]
]
},
'qt_version%': '<(qt_version)',
'qt_loc_unix': '<(linux_path_qt)',
'conditions': [
[ 'build_win', {
'qt_lib_prefix': '<(ld_lib_prefix)',
'qt_lib_debug_postfix': 'd<(ld_lib_postfix)',
'qt_lib_release_postfix': '<(ld_lib_postfix)',
'qt_libs': [
'<@(qt_libs)',
'Qt5Core',
'qtmain',
'qwindows',
'qtfreetype',
'qtpcre',
],
}],
[ 'build_mac', {
'qt_lib_prefix': '<(ld_lib_prefix)',
'qt_lib_debug_postfix': '_debug<(ld_lib_postfix)',
'qt_lib_release_postfix': '<(ld_lib_postfix)',
'qt_libs': [
'<@(qt_libs)',
'Qt5Core',
'qgenericbearer',
'qcocoa',
],
}],
[ 'build_mac and not build_macold', {
'qt_libs': [
'<@(qt_libs)',
'Qt5Core',
'qtfreetype',
'qtpcre',
],
}],
[ 'build_linux', {
'qt_lib_prefix': 'lib',
'qt_lib_debug_postfix': '.a',
'qt_lib_release_postfix': '.a',
'qt_libs': [
'qxcb',
'Qt5XcbQpa',
'qconnmanbearer',
'qgenericbearer',
'qnmbearer',
'<@(qt_libs)',
'Qt5DBus',
'Qt5Core',
'qtpcre',
'Xi',
'Xext',
'Xfixes',
'SM',
'ICE',
'fontconfig',
'expat',
'freetype',
'z',
'xcb-shm',
'xcb-xfixes',
'xcb-render',
'xcb-static',
],
}],
],
},
'qt_version%': '<(qt_version)',
'qt_loc_unix': '<(qt_loc_unix)',
'qt_version_loc': '<!(python -c "print(\'<(qt_version)\'.replace(\'.\', \'_\'))")',
'qt_libs_debug': [
'<!@(python -c "for s in \'<@(qt_libs)\'.split(\' \'): print(\'<(qt_lib_prefix)\' + s + \'<(qt_lib_debug_postfix)\')")',
],
'qt_libs_release': [
'<!@(python -c "for s in \'<@(qt_libs)\'.split(\' \'): print(\'<(qt_lib_prefix)\' + s + \'<(qt_lib_release_postfix)\')")',
],
},
'qt_libs_debug': [ '<@(qt_libs_debug)' ],
'qt_libs_release': [ '<@(qt_libs_release)' ],
'qt_version%': '<(qt_version)',
'conditions': [
[ 'build_win', {
'qt_loc': '<(DEPTH)/../../../Libraries/qt<(qt_version_loc)/qtbase',
}, {
'qt_loc': '<(qt_loc_unix)',
}],
],
# If you need moc sources include a line in your 'sources':
# '<!@(python <(DEPTH)/list_sources.py [sources] <(qt_moc_list_sources_arg))'
# where [sources] contains all your source files
'qt_moc_list_sources_arg': '--moc-prefix SHARED_INTERMEDIATE_DIR/<(_target_name)/moc/moc_',
'linux_path_xkbcommon%': '/usr/local',
'linux_lib_ssl%': '/usr/local/ssl/lib/libssl.a',
'linux_lib_crypto%': '/usr/local/ssl/lib/libcrypto.a',
'linux_lib_icu%': '/usr/lib/libicutu.a /usr/lib/libicui18n.a /usr/lib/libicuuc.a /usr/lib/libicudata.a',
},
'configurations': {
'Debug': {
'conditions' : [
[ 'build_win', {
'msvs_settings': {
'VCLinkerTool': {
'AdditionalDependencies': [
'<@(qt_libs_debug)',
],
},
},
}],
[ 'build_mac', {
'xcode_settings': {
'OTHER_LDFLAGS': [
'<@(qt_libs_debug)',
'/usr/local/lib/libz.a',
],
},
}],
],
},
'Release': {
'conditions' : [
[ 'build_win', {
'msvs_settings': {
'VCLinkerTool': {
'AdditionalDependencies': [
'<@(qt_libs_release)',
],
},
},
}],
[ 'build_mac', {
'xcode_settings': {
'OTHER_LDFLAGS': [
'<@(qt_libs_release)',
'/usr/local/lib/libz.a',
],
},
}],
],
},
},
'include_dirs': [
'<(qt_loc)/include',
'<(qt_loc)/include/QtCore',
'<(qt_loc)/include/QtGui',
'<(qt_loc)/include/QtDBus',
'<(qt_loc)/include/QtCore/<(qt_version)',
'<(qt_loc)/include/QtGui/<(qt_version)',
'<(qt_loc)/include/QtCore/<(qt_version)/QtCore',
'<(qt_loc)/include/QtGui/<(qt_version)/QtGui',
],
'library_dirs': [
'<(qt_loc)/lib',
'<(qt_loc)/plugins',
'<(qt_loc)/plugins/bearer',
'<(qt_loc)/plugins/platforms',
'<(qt_loc)/plugins/imageformats',
],
'defines': [
'QT_WIDGETS_LIB',
'QT_NETWORK_LIB',
'QT_GUI_LIB',
'QT_CORE_LIB',
],
'conditions': [
[ 'build_linux', {
'library_dirs': [
'<(qt_loc)/plugins/platforminputcontexts',
],
'libraries': [
'<(linux_path_xkbcommon)/lib/libxkbcommon.a',
'<@(qt_libs_release)',
'<(linux_lib_ssl)',
'<(linux_lib_crypto)',
'<!@(python -c "for s in \'<(linux_lib_icu)\'.split(\' \'): print(s)")',
'-lxcb',
'-lX11',
'-lX11-xcb',
'-ldbus-1',
'-ldl',
'-lgthread-2.0',
'-lglib-2.0',
'-lpthread',
],
'include_dirs': [
'<(qt_loc)/mkspecs/linux-g++',
],
'ldflags': [
'-static-libstdc++',
'-pthread',
'-g',
'-rdynamic',
],
}],
[ 'build_mac', {
'xcode_settings': {
'OTHER_LDFLAGS': [
'-lcups',
],
},
}],
],
}

40
Telegram/gyp/qt_moc.gypi
View File

@ -1,40 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'rules': [{
'rule_name': 'qt_moc',
'extension': 'h',
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/<(_target_name)/moc/moc_<(RULE_INPUT_ROOT).cpp',
],
'action': [
'<(qt_loc)/bin/moc<(exe_ext)',
# Silence "Note: No relevant classes found. No output generated."
'--no-notes',
'<!@(python -c "for s in \'<@(_defines)\'.split(\' \'): print(\'-D\' + s)")',
# '<!@(python -c "for s in \'<@(_include_dirs)\'.split(\' \'): print(\'-I\' + s)")',
'<(RULE_INPUT_PATH)',
'-o', '<(SHARED_INTERMEDIATE_DIR)/<(_target_name)/moc/moc_<(RULE_INPUT_ROOT).cpp',
],
'message': 'Moc-ing <(RULE_INPUT_ROOT).h..',
}],
}

40
Telegram/gyp/qt_rcc.gypi
View File

@ -1,40 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'rules': [{
'rule_name': 'qt_rcc',
'extension': 'qrc',
'inputs': [
'<(SHARED_INTERMEDIATE_DIR)/update_dependent_qrc.timestamp',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/<(_target_name)/qrc/qrc_<(RULE_INPUT_ROOT).cpp',
],
'action': [
'<(qt_loc)/bin/rcc<(exe_ext)',
'-name', '<(RULE_INPUT_ROOT)',
'-no-compress',
'<(RULE_INPUT_PATH)',
'-o', '<(SHARED_INTERMEDIATE_DIR)/<(_target_name)/qrc/qrc_<(RULE_INPUT_ROOT).cpp',
],
'message': 'Rcc-ing <(RULE_INPUT_ROOT).qrc..',
'process_outputs_as_sources': 1,
}],
}

63
Telegram/gyp/refresh.bat
View File

@ -1,63 +0,0 @@
@echo OFF
setlocal EnableDelayedExpansion
set "FullScriptPath=%~dp0"
set "FullExecPath=%cd%"
set "Silence=>nul"
if "%1" == "-v" set "Silence="
if exist "%FullScriptPath%..\build\target" (
FOR /F "tokens=1* delims= " %%i in (%FullScriptPath%..\build\target) do set "BuildTarget=%%i"
) else (
set "BuildTarget="
)
rem strangely linking of Release Telegram build complains about the absence of lib.pdb
if exist "%FullScriptPath%..\..\..\Libraries\openssl\tmp32\lib.pdb" (
if not exist "%FullScriptPath%..\..\..\Libraries\openssl\Release\lib\lib.pdb" (
xcopy "%FullScriptPath%..\..\..\Libraries\openssl\tmp32\lib.pdb" "%FullScriptPath%..\..\..\Libraries\openssl\Release\lib\" %Silence%
)
)
set BUILD_DEFINES=
if not "%TDESKTOP_BUILD_DEFINES%" == "" (
set "BUILD_DEFINES=-Dbuild_defines=%TDESKTOP_BUILD_DEFINES%"
echo [INFO] Set build defines to !BUILD_DEFINES!
)
set GYP_MSVS_VERSION=2017
cd "%FullScriptPath%"
call gyp --depth=. --generator-output=.. -Goutput_dir=../out !BUILD_DEFINES! -Dofficial_build_target=%BuildTarget% Telegram.gyp --format=ninja
if %errorlevel% neq 0 goto error
call gyp --depth=. --generator-output=.. -Goutput_dir=../out !BUILD_DEFINES! -Dofficial_build_target=%BuildTarget% Telegram.gyp --format=msvs-ninja
if %errorlevel% neq 0 goto error
cd ../..
rem looks like ninja build works without sdk 7.1 which was used by generating custom environment.arch files
rem cd "%FullScriptPath%"
rem call gyp --depth=. --generator-output=../.. -Goutput_dir=out -Gninja_use_custom_environment_files=1 Telegram.gyp --format=ninja
rem if %errorlevel% neq 0 goto error
rem call gyp --depth=. --generator-output=../.. -Goutput_dir=out -Gninja_use_custom_environment_files=1 Telegram.gyp --format=msvs-ninja
rem if %errorlevel% neq 0 goto error
rem cd ../..
rem call msbuild /target:SetBuildDefaultEnvironmentVariables Telegram.vcxproj /fileLogger %Silence%
rem if %errorlevel% neq 0 goto error
rem call python "%FullScriptPath%create_env.py"
rem if %errorlevel% neq 0 goto error
rem call move environment.x86 out\Debug\ %Silence%
rem if %errorlevel% neq 0 goto error
cd "%FullExecPath%"
exit /b
:error
echo FAILED
if exist "%FullScriptPath%..\..\msbuild.log" del "%FullScriptPath%..\..\msbuild.log"
if exist "%FullScriptPath%..\..\environment.x86" del "%FullScriptPath%..\..\environment.x86"
cd "%FullExecPath%"
exit /b 1

38
Telegram/gyp/refresh.sh
View File

@ -1,38 +0,0 @@
#!/usr/bin/env bash
set -e
FullExecPath=$PWD
pushd `dirname $0` > /dev/null
FullScriptPath=`pwd`
popd > /dev/null
if [ -f "$FullScriptPath/../build/target" ]; then
while IFS='' read -r line || [[ -n "$line" ]]; do
BuildTarget="$line"
done < "$FullScriptPath/../build/target"
else
BuildTarget=""
fi
MySystem=`uname -s`
cd $FullScriptPath
if [ "$MySystem" == "Linux" ]; then
../../../Libraries/gyp/gyp --depth=. --generator-output=.. -Goutput_dir=../out -Dofficial_build_target=$BuildTarget Telegram.gyp --format=cmake
cd ../../out/Debug
../../../Libraries/cmake-3.6.2/bin/cmake .
cd ../Release
../../../Libraries/cmake-3.6.2/bin/cmake .
cd ../../Telegram/gyp
else
#gyp --depth=. --generator-output=../.. -Goutput_dir=out Telegram.gyp --format=ninja
#gyp --depth=. --generator-output=../.. -Goutput_dir=out Telegram.gyp --format=xcode-ninja
#gyp --depth=. --generator-output=../.. -Goutput_dir=out Telegram.gyp --format=xcode
# use patched gyp with Xcode project generator
../../../Libraries/gyp/gyp --depth=. --generator-output=.. -Goutput_dir=../out -Gxcode_upgrade_check_project_version=830 -Dofficial_build_target=$BuildTarget Telegram.gyp --format=xcode
fi
cd ../..
cd $FullExecPath
exit

81
Telegram/gyp/settings_linux.gypi
View File

@ -1,81 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [
[ 'build_linux', {
'variables': {
'linux_common_flags': [
'-pipe',
'-g',
'-Wall',
'-Werror',
'-W',
'-fPIC',
'-Wno-unused-variable',
'-Wno-unused-parameter',
'-Wno-unused-function',
'-Wno-switch',
'-Wno-comment',
'-Wno-unused-but-set-variable',
'-Wno-missing-field-initializers',
'-Wno-sign-compare',
],
},
'conditions': [
[ '"<!(uname -p)" == "x86_64"', {
'defines': [
'Q_OS_LINUX64',
],
'conditions': [
[ '"<(official_build_target)" != "" and "<(official_build_target)" != "linux"', {
'sources': [ '__Wrong_Official_Build_Target_<(official_build_target)_' ],
}],
],
}, {
'defines': [
'Q_OS_LINUX32',
],
'conditions': [
[ '"<(official_build_target)" != "" and "<(official_build_target)" != "linux32"', {
'sources': [ '__Wrong_Official_Build_Target_<(official_build_target)_' ],
}],
],
}],
],
'defines': [
'_REENTRANT',
'QT_STATICPLUGIN',
'QT_PLUGIN',
],
'cflags_c': [
'<@(linux_common_flags)',
'-std=gnu11',
],
'cflags_cc': [
'<@(linux_common_flags)',
'-std=gnu++14',
],
'configurations': {
'Debug': {
},
},
}],
],
}

112
Telegram/gyp/settings_mac.gypi
View File

@ -1,112 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [
[ 'build_mac', {
'variables': {
'mac_frameworks': [
'Cocoa',
'CoreFoundation',
'CoreServices',
'CoreText',
'CoreGraphics',
'OpenGL',
'AudioUnit',
'ApplicationServices',
'Foundation',
'AGL',
'Security',
'SystemConfiguration',
'Carbon',
'AudioToolbox',
'CoreAudio',
'QuartzCore',
'AppKit',
'CoreWLAN',
'IOKit',
],
'mac_common_flags': [
'-pipe',
'-g',
'-Wall',
'-Werror',
'-W',
'-fPIE',
'-Wno-unused-variable',
'-Wno-unused-parameter',
'-Wno-unused-function',
'-Wno-switch',
'-Wno-comment',
'-Wno-missing-field-initializers',
'-Wno-sign-compare',
],
},
'xcode_settings': {
'SYMROOT': '../../out',
'OTHER_CFLAGS': [
'<@(mac_common_flags)',
],
'OTHER_CPLUSPLUSFLAGS': [
'<@(mac_common_flags)',
],
'OTHER_LDFLAGS': [
'<!@(python -c "for s in \'<@(mac_frameworks)\'.split(\' \'): print(\'-framework \' + s)")',
],
'MACOSX_DEPLOYMENT_TARGET': '<(mac_target)',
'COMBINE_HIDPI_IMAGES': 'YES',
'COPY_PHASE_STRIP': 'NO',
'CLANG_CXX_LANGUAGE_STANDARD': 'c++1z',
},
'configurations': {
'Debug': {
'xcode_settings': {
'ENABLE_TESTABILITY': 'YES',
'ONLY_ACTIVE_ARCH': 'YES',
},
},
},
'conditions': [
[ '"<(official_build_target)" != "" and "<(official_build_target)" != "mac" and "<(official_build_target)" != "mac32" and "<(official_build_target)" != "macstore"', {
'sources': [ '__Wrong_Official_Build_Target__' ],
}],
],
}],
[ 'build_macold', {
'xcode_settings': {
'OTHER_CPLUSPLUSFLAGS': [
'-Wno-inconsistent-missing-override',
],
'OTHER_LDFLAGS': [
'-w', # Suppress 'libstdc++ is deprecated' warning.
],
},
}, {
'xcode_settings': {
'CLANG_CXX_LIBRARY': 'libc++',
'OTHER_LDFLAGS': [
'-framework', 'VideoToolbox',
'-framework', 'VideoDecodeAcceleration',
'-framework', 'AVFoundation',
'-framework', 'CoreMedia',
],
},
}],
],
}

121
Telegram/gyp/settings_win.gypi
View File

@ -1,121 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [
[ 'build_win', {
'defines': [
'WIN32',
'_WINDOWS',
'_UNICODE',
'UNICODE',
'HAVE_STDINT_H',
'ZLIB_WINAPI',
'_SCL_SECURE_NO_WARNINGS',
'_USING_V110_SDK71_',
],
'msvs_cygwin_shell': 0,
'msvs_settings': {
'VCCLCompilerTool': {
'ProgramDataBaseFileName': '$(OutDir)\\$(ProjectName).pdb',
'DebugInformationFormat': '3', # Program Database (/Zi)
'AdditionalOptions': [
'/std:c++latest',
'/MP', # Enable multi process build.
'/EHsc', # Catch C++ exceptions only, extern C functions never throw a C++ exception.
'/WX', # Treat warnings as errors.
'/std:c++latest',
],
'TreatWChar_tAsBuiltInType': 'false',
},
'VCLinkerTool': {
'MinimumRequiredVersion': '5.01',
'ImageHasSafeExceptionHandlers': 'false', # Disable /SAFESEH
},
},
'msvs_external_builder_build_cmd': [
'ninja.exe',
'-C',
'$(OutDir)',
'-k0',
'$(ProjectName)',
],
'libraries': [
'-lwinmm',
'-limm32',
'-lws2_32',
'-lkernel32',
'-luser32',
'-lgdi32',
'-lwinspool',
'-lcomdlg32',
'-ladvapi32',
'-lshell32',
'-lole32',
'-loleaut32',
'-luuid',
'-lodbc32',
'-lodbccp32',
'-lShlwapi',
'-lIphlpapi',
'-lGdiplus',
'-lStrmiids',
],
'configurations': {
'Debug': {
'msvs_settings': {
'VCCLCompilerTool': {
'Optimization': '0', # Disabled (/Od)
'RuntimeLibrary': '1', # Multi-threaded Debug (/MTd)
},
'VCLinkerTool': {
'GenerateDebugInformation': 'true', # true (/DEBUG)
'IgnoreDefaultLibraryNames': 'LIBCMT',
'LinkIncremental': '2', # Yes (/INCREMENTAL)
},
},
},
'Release': {
'msvs_settings': {
'VCCLCompilerTool': {
'Optimization': '2', # Maximize Speed (/O2)
'InlineFunctionExpansion': '2', # Any suitable (/Ob2)
'EnableIntrinsicFunctions': 'true', # Yes (/Oi)
'FavorSizeOrSpeed': '1', # Favor fast code (/Ot)
'RuntimeLibrary': '0', # Multi-threaded (/MT)
'EnableEnhancedInstructionSet': '2', # Streaming SIMD Extensions 2 (/arch:SSE2)
'WholeProgramOptimization': 'true', # /GL
},
'VCLinkerTool': {
'GenerateDebugInformation': 'true', # /DEBUG
'OptimizeReferences': '2',
'LinkTimeCodeGeneration': '1', # /LTCG
},
},
},
},
'conditions': [
[ '"<(official_build_target)" != "" and "<(official_build_target)" != "win" and "<(official_build_target)" != "uwp"', {
'sources': [ '__Wrong_Official_Build_Target__' ],
}],
],
}],
],
}

106
Telegram/gyp/telegram_linux.gypi
View File

@ -1,106 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [[ 'build_linux', {
'variables': {
'not_need_gtk%': '<!(python -c "print(\'TDESKTOP_DISABLE_GTK_INTEGRATION\' in \'<(build_defines)\')")',
'pkgconfig_libs': [
# In order to work libxkbcommon must be linked statically,
# PKGCONFIG links it like "-L/usr/local/lib -lxkbcommon"
# which makes a dynamic link which leads to segfault in
# QApplication() -> createPlatformIntegration -> QXcbIntegrationPlugin::create
#'xkbcommon',
],
'linux_path_ffmpeg%': '/usr/local',
'linux_path_openal%': '/usr/local',
'linux_path_libexif_lib%': '<(libs_loc)/libexif-0.6.20/libexif/.libs',
'linux_path_va%': '/usr/local',
'linux_path_vdpau%': '/usr/local',
'linux_path_breakpad%': '<(libs_loc)/breakpad',
'linux_path_opus_include%': '<(libs_loc)/opus/include',
},
'include_dirs': [
'/usr/local/include',
'<(linux_path_ffmpeg)/include',
'<(linux_path_openal)/include',
'<(linux_path_breakpad)/include/breakpad',
'<(linux_path_opus_include)',
],
'library_dirs': [
'/usr/local/lib',
'<(linux_path_ffmpeg)/lib',
'<(linux_path_openal)/lib',
'<(linux_path_libexif_lib)',
'<(linux_path_va)/lib',
'<(linux_path_vdpau)/lib',
'<(linux_path_breakpad)/lib',
],
'libraries': [
'breakpad_client',
'composeplatforminputcontextplugin',
'ibusplatforminputcontextplugin',
'fcitxplatforminputcontextplugin',
'himeplatforminputcontextplugin',
'liblzma.a',
'libopenal.a',
'libavformat.a',
'libavcodec.a',
'libswresample.a',
'libswscale.a',
'libavutil.a',
'libopus.a',
'libva-x11.a',
'libva-drm.a',
'libva.a',
'libvdpau.a',
'libdrm.a',
'libz.a',
# '<!(pkg-config 2> /dev/null --libs <@(pkgconfig_libs))',
],
'conditions': [['not_need_gtk!="True"', {
'cflags_cc': [
'<!(pkg-config 2> /dev/null --cflags appindicator-0.1)',
'<!(pkg-config 2> /dev/null --cflags gtk+-2.0)',
'<!(pkg-config 2> /dev/null --cflags glib-2.0)',
'<!(pkg-config 2> /dev/null --cflags dee-1.0)',
],
}]],
'configurations': {
'Release': {
'cflags': [
'-Ofast',
'-flto',
'-fno-strict-aliasing',
],
'cflags_cc': [
'-Ofast',
'-flto',
'-fno-strict-aliasing',
],
'ldflags': [
'-Ofast',
'-flto',
],
},
},
'cmake_precompiled_header': '<(src_loc)/stdafx.h',
'cmake_precompiled_header_script': 'PrecompiledHeader.cmake',
}]],
}

233
Telegram/gyp/telegram_mac.gypi
View File

@ -1,233 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [[ 'build_mac', {
'xcode_settings': {
'GCC_PREFIX_HEADER': '<(src_loc)/stdafx.h',
'GCC_PRECOMPILE_PREFIX_HEADER': 'YES',
'INFOPLIST_FILE': '../Telegram.plist',
'CURRENT_PROJECT_VERSION': '<!(./print_version.sh)',
'ASSETCATALOG_COMPILER_APPICON_NAME': 'AppIcon',
'OTHER_LDFLAGS': [
'-lbsm',
'-lm',
'/usr/local/lib/liblzma.a',
],
},
'include_dirs': [
'/usr/local/include',
],
'library_dirs': [
'/usr/local/lib',
],
'configurations': {
'Debug': {
'xcode_settings': {
'GCC_OPTIMIZATION_LEVEL': '0',
},
},
'Release': {
'xcode_settings': {
'DEBUG_INFORMATION_FORMAT': 'dwarf-with-dsym',
'LLVM_LTO': 'YES',
'GCC_OPTIMIZATION_LEVEL': 'fast',
},
},
},
'mac_bundle': '1',
'mac_bundle_resources': [
'<!@(python -c "for s in \'<@(langpacks)\'.split(\' \'): print(\'<(res_loc)/langs/\' + s + \'.lproj/Localizable.strings\')")',
'../Telegram/Images.xcassets',
],
}], [ 'build_macold', {
'xcode_settings': {
'PRODUCT_BUNDLE_IDENTIFIER': 'com.tdesktop.Telegram',
'OTHER_CPLUSPLUSFLAGS': [ '-nostdinc++' ],
'OTHER_LDFLAGS': [
'-lbase',
'-lcrashpad_client',
'-lcrashpad_util',
'/usr/local/macold/lib/libz.a',
'/usr/local/macold/lib/libopus.a',
'/usr/local/macold/lib/libopenal.a',
'/usr/local/macold/lib/libiconv.a',
'/usr/local/macold/lib/libavcodec.a',
'/usr/local/macold/lib/libavformat.a',
'/usr/local/macold/lib/libavutil.a',
'/usr/local/macold/lib/libswscale.a',
'/usr/local/macold/lib/libswresample.a',
'/usr/local/macold/lib/libexif.a',
'/usr/local/macold/lib/libc++.a',
'/usr/local/macold/lib/libc++abi.a',
'<(libs_loc)/macold/openssl-1.0.1h/libssl.a',
'<(libs_loc)/macold/openssl-1.0.1h/libcrypto.a',
],
},
'include_dirs': [
'/usr/local/macold',
'/usr/local/macold/include/c++/v1',
'<(libs_loc)/macold/openssl-1.0.1h/include',
'<(libs_loc)/macold/crashpad',
'<(libs_loc)/macold/crashpad/third_party/mini_chromium/mini_chromium',
],
'configurations': {
'Debug': {
'library_dirs': [
'<(libs_loc)/macold/crashpad/out/Debug',
],
},
'Release': {
'library_dirs': [
'<(libs_loc)/macold/crashpad/out/Release',
],
},
},
'postbuilds': [{
'postbuild_name': 'Force Frameworks path',
'action': [
'mkdir', '-p', '${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Frameworks/'
],
}, {
'postbuild_name': 'Copy Updater to Frameworks',
'action': [
'cp',
'${BUILT_PRODUCTS_DIR}/Updater',
'${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Frameworks/',
],
}, {
'postbuild_name': 'Force Helpers path',
'action': [
'mkdir', '-p', '${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Helpers/'
],
}, {
'postbuild_name': 'Copy crashpad_handler to Helpers',
'action': [
'cp',
'<(libs_loc)/macold/crashpad/out/${CONFIGURATION}/crashpad_handler',
'${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Helpers/',
],
}],
}, {
'xcode_settings': {
'OTHER_LDFLAGS': [
'/usr/local/lib/libz.a',
'/usr/local/lib/libopus.a',
'/usr/local/lib/libopenal.a',
'/usr/local/lib/libiconv.a',
'/usr/local/lib/libavcodec.a',
'/usr/local/lib/libavformat.a',
'/usr/local/lib/libavutil.a',
'/usr/local/lib/libswscale.a',
'/usr/local/lib/libswresample.a',
'<(libs_loc)/openssl-xcode/libssl.a',
'<(libs_loc)/openssl-xcode/libcrypto.a',
],
},
'include_dirs': [
'<(libs_loc)/crashpad',
'<(libs_loc)/crashpad/third_party/mini_chromium/mini_chromium',
'<(libs_loc)/openssl-xcode/include'
],
'configurations': {
'Debug': {
'library_dirs': [
'<(libs_loc)/crashpad/out/Debug',
],
},
'Release': {
'library_dirs': [
'<(libs_loc)/crashpad/out/Release',
],
},
},
}], [ '"<(build_macold)" != "1" and "<(build_macstore)" != "1"', {
'xcode_settings': {
'PRODUCT_BUNDLE_IDENTIFIER': 'com.tdesktop.Telegram',
'OTHER_LDFLAGS': [
'-lbase',
'-lcrashpad_client',
'-lcrashpad_util',
],
},
'postbuilds': [{
'postbuild_name': 'Force Frameworks path',
'action': [
'mkdir', '-p', '${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Frameworks/'
],
}, {
'postbuild_name': 'Copy Updater to Frameworks',
'action': [
'cp',
'${BUILT_PRODUCTS_DIR}/Updater',
'${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Frameworks/',
],
}, {
'postbuild_name': 'Force Helpers path',
'action': [
'mkdir', '-p', '${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Helpers/'
],
}, {
'postbuild_name': 'Copy crashpad_client to Helpers',
'action': [
'cp',
'<(libs_loc)/crashpad/out/${CONFIGURATION}/crashpad_handler',
'${BUILT_PRODUCTS_DIR}/Telegram.app/Contents/Helpers/',
],
}],
}], [ 'build_macstore', {
'xcode_settings': {
'PRODUCT_BUNDLE_IDENTIFIER': 'org.telegram.desktop',
'OTHER_LDFLAGS': [
'-framework', 'Breakpad',
],
'FRAMEWORK_SEARCH_PATHS': [
'<(libs_loc)/breakpad/src/client/mac/build/Release',
],
},
'mac_sandbox': 1,
'mac_sandbox_development_team': '6N38VWS5BX',
'product_name': 'Telegram Desktop',
'sources': [
'../Telegram/Telegram Desktop.entitlements',
],
'defines': [
'TDESKTOP_DISABLE_AUTOUPDATE',
'OS_MAC_STORE',
],
'postbuilds': [{
'postbuild_name': 'Clear Frameworks path',
'action': [
'rm', '-rf', '${BUILT_PRODUCTS_DIR}/Telegram Desktop.app/Contents/Frameworks'
],
}, {
'postbuild_name': 'Force Frameworks path',
'action': [
'mkdir', '-p', '${BUILT_PRODUCTS_DIR}/Telegram Desktop.app/Contents/Frameworks/'
],
}, {
'postbuild_name': 'Copy Breakpad.framework to Frameworks',
'action': [
'cp', '-a',
'<(libs_loc)/breakpad/src/client/mac/build/Release/Breakpad.framework',
'${BUILT_PRODUCTS_DIR}/Telegram Desktop.app/Contents/Frameworks/Breakpad.framework',
],
}]
}]],
}

52
Telegram/gyp/telegram_qrc.gypi
View File

@ -1,52 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'variables': {
'qrc_files': [
'<(res_loc)/qrc/telegram.qrc',
'<(res_loc)/qrc/telegram_emoji.qrc',
'<(res_loc)/qrc/telegram_emoji_large.qrc',
'<(res_loc)/qrc/telegram_sounds.qrc',
],
},
'conditions': [
[ 'build_linux', {
'variables': {
'qrc_files': [
'<(res_loc)/qrc/telegram_linux.qrc',
],
}
}],
[ 'build_mac', {
'variables': {
'qrc_files': [
'<(res_loc)/qrc/telegram_mac.qrc',
],
},
}],
[ 'build_win', {
'variables': {
'qrc_files': [
'<(res_loc)/qrc/telegram_wnd.qrc',
],
}
}],
],
}

612
Telegram/gyp/telegram_sources.txt
View File

@ -1,612 +0,0 @@
<(src_loc)/base/algorithm.h
<(src_loc)/base/assertion.h
<(src_loc)/base/build_config.h
<(src_loc)/base/flags.h
<(src_loc)/base/flat_map.h
<(src_loc)/base/flat_set.h
<(src_loc)/base/lambda.h
<(src_loc)/base/lambda_guard.h
<(src_loc)/base/observer.cpp
<(src_loc)/base/observer.h
<(src_loc)/base/ordered_set.h
<(src_loc)/base/openssl_help.h
<(src_loc)/base/optional.h
<(src_loc)/base/parse_helper.cpp
<(src_loc)/base/parse_helper.h
<(src_loc)/base/qthelp_regex.h
<(src_loc)/base/qthelp_url.cpp
<(src_loc)/base/qthelp_url.h
<(src_loc)/base/runtime_composer.cpp
<(src_loc)/base/runtime_composer.h
<(src_loc)/base/task_queue.cpp
<(src_loc)/base/task_queue.h
<(src_loc)/base/timer.cpp
<(src_loc)/base/timer.h
<(src_loc)/base/type_traits.h
<(src_loc)/base/variant.h
<(src_loc)/base/virtual_method.h
<(src_loc)/base/weak_unique_ptr.h
<(src_loc)/base/zlib_help.h
<(src_loc)/boxes/about_box.cpp
<(src_loc)/boxes/about_box.h
<(src_loc)/boxes/abstract_box.cpp
<(src_loc)/boxes/abstract_box.h
<(src_loc)/boxes/add_contact_box.cpp
<(src_loc)/boxes/add_contact_box.h
<(src_loc)/boxes/autolock_box.cpp
<(src_loc)/boxes/autolock_box.h
<(src_loc)/boxes/background_box.cpp
<(src_loc)/boxes/background_box.h
<(src_loc)/boxes/calendar_box.cpp
<(src_loc)/boxes/calendar_box.h
<(src_loc)/boxes/change_phone_box.cpp
<(src_loc)/boxes/change_phone_box.h
<(src_loc)/boxes/confirm_box.cpp
<(src_loc)/boxes/confirm_box.h
<(src_loc)/boxes/confirm_phone_box.cpp
<(src_loc)/boxes/confirm_phone_box.h
<(src_loc)/boxes/connection_box.cpp
<(src_loc)/boxes/connection_box.h
<(src_loc)/boxes/download_path_box.cpp
<(src_loc)/boxes/download_path_box.h
<(src_loc)/boxes/edit_color_box.cpp
<(src_loc)/boxes/edit_color_box.h
<(src_loc)/boxes/edit_participant_box.cpp
<(src_loc)/boxes/edit_participant_box.h
<(src_loc)/boxes/edit_privacy_box.cpp
<(src_loc)/boxes/edit_privacy_box.h
<(src_loc)/boxes/language_box.cpp
<(src_loc)/boxes/language_box.h
<(src_loc)/boxes/local_storage_box.cpp
<(src_loc)/boxes/local_storage_box.h
<(src_loc)/boxes/mute_settings_box.cpp
<(src_loc)/boxes/mute_settings_box.h
<(src_loc)/boxes/notifications_box.cpp
<(src_loc)/boxes/notifications_box.h
<(src_loc)/boxes/peer_list_box.cpp
<(src_loc)/boxes/peer_list_box.h
<(src_loc)/boxes/peer_list_controllers.cpp
<(src_loc)/boxes/peer_list_controllers.h
<(src_loc)/boxes/passcode_box.cpp
<(src_loc)/boxes/passcode_box.h
<(src_loc)/boxes/photo_crop_box.cpp
<(src_loc)/boxes/photo_crop_box.h
<(src_loc)/boxes/rate_call_box.cpp
<(src_loc)/boxes/rate_call_box.h
<(src_loc)/boxes/report_box.cpp
<(src_loc)/boxes/report_box.h
<(src_loc)/boxes/self_destruction_box.cpp
<(src_loc)/boxes/self_destruction_box.h
<(src_loc)/boxes/send_files_box.cpp
<(src_loc)/boxes/send_files_box.h
<(src_loc)/boxes/sessions_box.cpp
<(src_loc)/boxes/sessions_box.h
<(src_loc)/boxes/share_box.cpp
<(src_loc)/boxes/share_box.h
<(src_loc)/boxes/sticker_set_box.cpp
<(src_loc)/boxes/sticker_set_box.h
<(src_loc)/boxes/stickers_box.cpp
<(src_loc)/boxes/stickers_box.h
<(src_loc)/boxes/username_box.cpp
<(src_loc)/boxes/username_box.h
<(src_loc)/calls/calls_box_controller.cpp
<(src_loc)/calls/calls_box_controller.h
<(src_loc)/calls/calls_call.cpp
<(src_loc)/calls/calls_call.h
<(src_loc)/calls/calls_emoji_fingerprint.cpp
<(src_loc)/calls/calls_emoji_fingerprint.h
<(src_loc)/calls/calls_instance.cpp
<(src_loc)/calls/calls_instance.h
<(src_loc)/calls/calls_panel.cpp
<(src_loc)/calls/calls_panel.h
<(src_loc)/calls/calls_top_bar.cpp
<(src_loc)/calls/calls_top_bar.h
<(src_loc)/chat_helpers/bot_keyboard.cpp
<(src_loc)/chat_helpers/bot_keyboard.h
<(src_loc)/chat_helpers/emoji_list_widget.cpp
<(src_loc)/chat_helpers/emoji_list_widget.h
<(src_loc)/chat_helpers/emoji_suggestions_helper.h
<(src_loc)/chat_helpers/emoji_suggestions_widget.cpp
<(src_loc)/chat_helpers/emoji_suggestions_widget.h
<(src_loc)/chat_helpers/field_autocomplete.cpp
<(src_loc)/chat_helpers/field_autocomplete.h
<(src_loc)/chat_helpers/gifs_list_widget.cpp
<(src_loc)/chat_helpers/gifs_list_widget.h
<(src_loc)/chat_helpers/message_field.cpp
<(src_loc)/chat_helpers/message_field.h
<(src_loc)/chat_helpers/stickers.cpp
<(src_loc)/chat_helpers/stickers.h
<(src_loc)/chat_helpers/stickers_list_widget.cpp
<(src_loc)/chat_helpers/stickers_list_widget.h
<(src_loc)/chat_helpers/tabbed_panel.cpp
<(src_loc)/chat_helpers/tabbed_panel.h
<(src_loc)/chat_helpers/tabbed_section.cpp
<(src_loc)/chat_helpers/tabbed_section.h
<(src_loc)/chat_helpers/tabbed_selector.cpp
<(src_loc)/chat_helpers/tabbed_selector.h
<(src_loc)/core/basic_types.h
<(src_loc)/core/click_handler.cpp
<(src_loc)/core/click_handler.h
<(src_loc)/core/click_handler_types.cpp
<(src_loc)/core/click_handler_types.h
<(src_loc)/core/file_utilities.cpp
<(src_loc)/core/file_utilities.h
<(src_loc)/core/single_timer.cpp
<(src_loc)/core/single_timer.h
<(src_loc)/core/utils.cpp
<(src_loc)/core/utils.h
<(src_loc)/core/version.h
<(src_loc)/data/data_abstract_structure.cpp
<(src_loc)/data/data_abstract_structure.h
<(src_loc)/data/data_drafts.cpp
<(src_loc)/data/data_drafts.h
<(src_loc)/dialogs/dialogs_common.h
<(src_loc)/dialogs/dialogs_indexed_list.cpp
<(src_loc)/dialogs/dialogs_indexed_list.h
<(src_loc)/dialogs/dialogs_inner_widget.cpp
<(src_loc)/dialogs/dialogs_inner_widget.h
<(src_loc)/dialogs/dialogs_layout.cpp
<(src_loc)/dialogs/dialogs_layout.h
<(src_loc)/dialogs/dialogs_list.cpp
<(src_loc)/dialogs/dialogs_list.h
<(src_loc)/dialogs/dialogs_row.cpp
<(src_loc)/dialogs/dialogs_row.h
<(src_loc)/dialogs/dialogs_search_from_controllers.cpp
<(src_loc)/dialogs/dialogs_search_from_controllers.h
<(src_loc)/dialogs/dialogs_widget.cpp
<(src_loc)/dialogs/dialogs_widget.h
<(src_loc)/history/history.cpp
<(src_loc)/history/history.h
<(src_loc)/history/history_admin_log_filter.cpp
<(src_loc)/history/history_admin_log_filter.h
<(src_loc)/history/history_admin_log_inner.cpp
<(src_loc)/history/history_admin_log_inner.h
<(src_loc)/history/history_admin_log_item.cpp
<(src_loc)/history/history_admin_log_item.h
<(src_loc)/history/history_admin_log_section.cpp
<(src_loc)/history/history_admin_log_section.h
<(src_loc)/history/history_common.h
<(src_loc)/history/history_drag_area.cpp
<(src_loc)/history/history_drag_area.h
<(src_loc)/history/history_item.cpp
<(src_loc)/history/history_item.h
<(src_loc)/history/history_inner_widget.cpp
<(src_loc)/history/history_inner_widget.h
<(src_loc)/history/history_location_manager.cpp
<(src_loc)/history/history_location_manager.h
<(src_loc)/history/history_media.h
<(src_loc)/history/history_media_types.cpp
<(src_loc)/history/history_media_types.h
<(src_loc)/history/history_message.cpp
<(src_loc)/history/history_message.h
<(src_loc)/history/history_service.cpp
<(src_loc)/history/history_service.h
<(src_loc)/history/history_service_layout.cpp
<(src_loc)/history/history_service_layout.h
<(src_loc)/history/history_widget.cpp
<(src_loc)/history/history_widget.h
<(src_loc)/inline_bots/inline_bot_layout_internal.cpp
<(src_loc)/inline_bots/inline_bot_layout_internal.h
<(src_loc)/inline_bots/inline_bot_layout_item.cpp
<(src_loc)/inline_bots/inline_bot_layout_item.h
<(src_loc)/inline_bots/inline_bot_result.cpp
<(src_loc)/inline_bots/inline_bot_result.h
<(src_loc)/inline_bots/inline_bot_send_data.cpp
<(src_loc)/inline_bots/inline_bot_send_data.h
<(src_loc)/inline_bots/inline_results_widget.cpp
<(src_loc)/inline_bots/inline_results_widget.h
<(src_loc)/intro/introwidget.cpp
<(src_loc)/intro/introwidget.h
<(src_loc)/intro/introcode.cpp
<(src_loc)/intro/introcode.h
<(src_loc)/intro/introphone.cpp
<(src_loc)/intro/introphone.h
<(src_loc)/intro/intropwdcheck.cpp
<(src_loc)/intro/intropwdcheck.h
<(src_loc)/intro/introsignup.cpp
<(src_loc)/intro/introsignup.h
<(src_loc)/intro/introstart.cpp
<(src_loc)/intro/introstart.h
<(src_loc)/lang/lang_cloud_manager.cpp
<(src_loc)/lang/lang_cloud_manager.h
<(src_loc)/lang/lang_file_parser.cpp
<(src_loc)/lang/lang_file_parser.h
<(src_loc)/lang/lang_instance.cpp
<(src_loc)/lang/lang_instance.h
<(src_loc)/lang/lang_keys.cpp
<(src_loc)/lang/lang_keys.h
<(src_loc)/lang/lang_tag.cpp
<(src_loc)/lang/lang_tag.h
<(src_loc)/lang/lang_translator.cpp
<(src_loc)/lang/lang_translator.h
<(src_loc)/media/player/media_player_button.cpp
<(src_loc)/media/player/media_player_button.h
<(src_loc)/media/player/media_player_cover.cpp
<(src_loc)/media/player/media_player_cover.h
<(src_loc)/media/player/media_player_float.cpp
<(src_loc)/media/player/media_player_float.h
<(src_loc)/media/player/media_player_instance.cpp
<(src_loc)/media/player/media_player_instance.h
<(src_loc)/media/player/media_player_list.cpp
<(src_loc)/media/player/media_player_list.h
<(src_loc)/media/player/media_player_panel.cpp
<(src_loc)/media/player/media_player_panel.h
<(src_loc)/media/player/media_player_volume_controller.cpp
<(src_loc)/media/player/media_player_volume_controller.h
<(src_loc)/media/player/media_player_widget.cpp
<(src_loc)/media/player/media_player_widget.h
<(src_loc)/media/view/media_clip_controller.cpp
<(src_loc)/media/view/media_clip_controller.h
<(src_loc)/media/view/media_clip_playback.cpp
<(src_loc)/media/view/media_clip_playback.h
<(src_loc)/media/view/media_clip_volume_controller.cpp
<(src_loc)/media/view/media_clip_volume_controller.h
<(src_loc)/media/media_audio.cpp
<(src_loc)/media/media_audio.h
<(src_loc)/media/media_audio_capture.cpp
<(src_loc)/media/media_audio_capture.h
<(src_loc)/media/media_audio_ffmpeg_loader.cpp
<(src_loc)/media/media_audio_ffmpeg_loader.h
<(src_loc)/media/media_audio_loader.cpp
<(src_loc)/media/media_audio_loader.h
<(src_loc)/media/media_audio_loaders.cpp
<(src_loc)/media/media_audio_loaders.h
<(src_loc)/media/media_audio_track.cpp
<(src_loc)/media/media_audio_track.h
<(src_loc)/media/media_child_ffmpeg_loader.cpp
<(src_loc)/media/media_child_ffmpeg_loader.h
<(src_loc)/media/media_clip_ffmpeg.cpp
<(src_loc)/media/media_clip_ffmpeg.h
<(src_loc)/media/media_clip_implementation.cpp
<(src_loc)/media/media_clip_implementation.h
<(src_loc)/media/media_clip_qtgif.cpp
<(src_loc)/media/media_clip_qtgif.h
<(src_loc)/media/media_clip_reader.cpp
<(src_loc)/media/media_clip_reader.h
<(src_loc)/mtproto/auth_key.cpp
<(src_loc)/mtproto/auth_key.h
<(src_loc)/mtproto/config_loader.cpp
<(src_loc)/mtproto/config_loader.h
<(src_loc)/mtproto/connection.cpp
<(src_loc)/mtproto/connection.h
<(src_loc)/mtproto/connection_abstract.cpp
<(src_loc)/mtproto/connection_abstract.h
<(src_loc)/mtproto/connection_auto.cpp
<(src_loc)/mtproto/connection_auto.h
<(src_loc)/mtproto/connection_http.cpp
<(src_loc)/mtproto/connection_http.h
<(src_loc)/mtproto/connection_tcp.cpp
<(src_loc)/mtproto/connection_tcp.h
<(src_loc)/mtproto/core_types.cpp
<(src_loc)/mtproto/core_types.h
<(src_loc)/mtproto/dcenter.cpp
<(src_loc)/mtproto/dcenter.h
<(src_loc)/mtproto/dc_options.cpp
<(src_loc)/mtproto/dc_options.h
<(src_loc)/mtproto/facade.cpp
<(src_loc)/mtproto/facade.h
<(src_loc)/mtproto/mtp_instance.cpp
<(src_loc)/mtproto/mtp_instance.h
<(src_loc)/mtproto/rsa_public_key.cpp
<(src_loc)/mtproto/rsa_public_key.h
<(src_loc)/mtproto/rpc_sender.cpp
<(src_loc)/mtproto/rpc_sender.h
<(src_loc)/mtproto/sender.h
<(src_loc)/mtproto/session.cpp
<(src_loc)/mtproto/session.h
<(src_loc)/mtproto/special_config_request.cpp
<(src_loc)/mtproto/special_config_request.h
<(src_loc)/mtproto/type_utils.cpp
<(src_loc)/mtproto/type_utils.h
<(src_loc)/overview/overview_layout.cpp
<(src_loc)/overview/overview_layout.h
<(src_loc)/platform/linux/linux_desktop_environment.cpp
<(src_loc)/platform/linux/linux_desktop_environment.h
<(src_loc)/platform/linux/linux_gdk_helper.cpp
<(src_loc)/platform/linux/linux_gdk_helper.h
<(src_loc)/platform/linux/linux_libnotify.cpp
<(src_loc)/platform/linux/linux_libnotify.h
<(src_loc)/platform/linux/linux_libs.cpp
<(src_loc)/platform/linux/linux_libs.h
<(src_loc)/platform/linux/file_utilities_linux.cpp
<(src_loc)/platform/linux/file_utilities_linux.h
<(src_loc)/platform/linux/main_window_linux.cpp
<(src_loc)/platform/linux/main_window_linux.h
<(src_loc)/platform/linux/notifications_manager_linux.cpp
<(src_loc)/platform/linux/notifications_manager_linux.h
<(src_loc)/platform/linux/specific_linux.cpp
<(src_loc)/platform/linux/specific_linux.h
<(src_loc)/platform/mac/file_utilities_mac.mm
<(src_loc)/platform/mac/file_utilities_mac.h
<(src_loc)/platform/mac/mac_iconv_helper.c
<(src_loc)/platform/mac/mac_utilities.mm
<(src_loc)/platform/mac/mac_utilities.h
<(src_loc)/platform/mac/main_window_mac.mm
<(src_loc)/platform/mac/main_window_mac.h
<(src_loc)/platform/mac/notifications_manager_mac.mm
<(src_loc)/platform/mac/notifications_manager_mac.h
<(src_loc)/platform/mac/specific_mac.mm
<(src_loc)/platform/mac/specific_mac.h
<(src_loc)/platform/mac/specific_mac_p.mm
<(src_loc)/platform/mac/specific_mac_p.h
<(src_loc)/platform/mac/window_title_mac.mm
<(src_loc)/platform/mac/window_title_mac.h
<(src_loc)/platform/win/audio_win.cpp
<(src_loc)/platform/win/audio_win.h
<(src_loc)/platform/win/file_utilities_win.cpp
<(src_loc)/platform/win/file_utilities_win.h
<(src_loc)/platform/win/main_window_win.cpp
<(src_loc)/platform/win/main_window_win.h
<(src_loc)/platform/win/notifications_manager_win.cpp
<(src_loc)/platform/win/notifications_manager_win.h
<(src_loc)/platform/win/specific_win.cpp
<(src_loc)/platform/win/specific_win.h
<(src_loc)/platform/win/window_title_win.cpp
<(src_loc)/platform/win/window_title_win.h
<(src_loc)/platform/win/windows_app_user_model_id.cpp
<(src_loc)/platform/win/windows_app_user_model_id.h
<(src_loc)/platform/win/windows_dlls.cpp
<(src_loc)/platform/win/windows_dlls.h
<(src_loc)/platform/win/windows_event_filter.cpp
<(src_loc)/platform/win/windows_event_filter.h
<(src_loc)/platform/platform_audio.h
<(src_loc)/platform/platform_file_utilities.h
<(src_loc)/platform/platform_main_window.h
<(src_loc)/platform/platform_notifications_manager.h
<(src_loc)/platform/platform_specific.h
<(src_loc)/platform/platform_window_title.h
<(src_loc)/profile/profile_back_button.cpp
<(src_loc)/profile/profile_back_button.h
<(src_loc)/profile/profile_block_actions.cpp
<(src_loc)/profile/profile_block_actions.h
<(src_loc)/profile/profile_block_channel_members.cpp
<(src_loc)/profile/profile_block_channel_members.h
<(src_loc)/profile/profile_block_info.cpp
<(src_loc)/profile/profile_block_info.h
<(src_loc)/profile/profile_block_invite_link.cpp
<(src_loc)/profile/profile_block_invite_link.h
<(src_loc)/profile/profile_block_group_members.cpp
<(src_loc)/profile/profile_block_group_members.h
<(src_loc)/profile/profile_block_peer_list.cpp
<(src_loc)/profile/profile_block_peer_list.h
<(src_loc)/profile/profile_block_settings.cpp
<(src_loc)/profile/profile_block_settings.h
<(src_loc)/profile/profile_block_shared_media.cpp
<(src_loc)/profile/profile_block_shared_media.h
<(src_loc)/profile/profile_block_widget.cpp
<(src_loc)/profile/profile_block_widget.h
<(src_loc)/profile/profile_channel_controllers.cpp
<(src_loc)/profile/profile_channel_controllers.h
<(src_loc)/profile/profile_common_groups_section.cpp
<(src_loc)/profile/profile_common_groups_section.h
<(src_loc)/profile/profile_cover_drop_area.cpp
<(src_loc)/profile/profile_cover_drop_area.h
<(src_loc)/profile/profile_cover.cpp
<(src_loc)/profile/profile_cover.h
<(src_loc)/profile/profile_fixed_bar.cpp
<(src_loc)/profile/profile_fixed_bar.h
<(src_loc)/profile/profile_inner_widget.cpp
<(src_loc)/profile/profile_inner_widget.h
<(src_loc)/profile/profile_section_memento.cpp
<(src_loc)/profile/profile_section_memento.h
<(src_loc)/profile/profile_userpic_button.cpp
<(src_loc)/profile/profile_userpic_button.h
<(src_loc)/profile/profile_widget.cpp
<(src_loc)/profile/profile_widget.h
<(src_loc)/settings/settings_advanced_widget.cpp
<(src_loc)/settings/settings_advanced_widget.h
<(src_loc)/settings/settings_background_widget.cpp
<(src_loc)/settings/settings_background_widget.h
<(src_loc)/settings/settings_block_widget.cpp
<(src_loc)/settings/settings_block_widget.h
<(src_loc)/settings/settings_chat_settings_widget.cpp
<(src_loc)/settings/settings_chat_settings_widget.h
<(src_loc)/settings/settings_cover.cpp
<(src_loc)/settings/settings_cover.h
<(src_loc)/settings/settings_fixed_bar.cpp
<(src_loc)/settings/settings_fixed_bar.h
<(src_loc)/settings/settings_general_widget.cpp
<(src_loc)/settings/settings_general_widget.h
<(src_loc)/settings/settings_info_widget.cpp
<(src_loc)/settings/settings_info_widget.h
<(src_loc)/settings/settings_inner_widget.cpp
<(src_loc)/settings/settings_inner_widget.h
<(src_loc)/settings/settings_layer.cpp
<(src_loc)/settings/settings_layer.h
<(src_loc)/settings/settings_notifications_widget.cpp
<(src_loc)/settings/settings_notifications_widget.h
<(src_loc)/settings/settings_privacy_controllers.cpp
<(src_loc)/settings/settings_privacy_controllers.h
<(src_loc)/settings/settings_privacy_widget.cpp
<(src_loc)/settings/settings_privacy_widget.h
<(src_loc)/settings/settings_scale_widget.cpp
<(src_loc)/settings/settings_scale_widget.h
<(src_loc)/settings/settings_widget.cpp
<(src_loc)/settings/settings_widget.h
<(src_loc)/storage/file_download.cpp
<(src_loc)/storage/file_download.h
<(src_loc)/storage/file_upload.cpp
<(src_loc)/storage/file_upload.h
<(src_loc)/storage/localimageloader.cpp
<(src_loc)/storage/localimageloader.h
<(src_loc)/storage/localstorage.cpp
<(src_loc)/storage/localstorage.h
<(src_loc)/storage/serialize_common.cpp
<(src_loc)/storage/serialize_common.h
<(src_loc)/storage/serialize_document.cpp
<(src_loc)/storage/serialize_document.h
<(src_loc)/ui/effects/cross_animation.cpp
<(src_loc)/ui/effects/cross_animation.h
<(src_loc)/ui/effects/panel_animation.cpp
<(src_loc)/ui/effects/panel_animation.h
<(src_loc)/ui/effects/radial_animation.cpp
<(src_loc)/ui/effects/radial_animation.h
<(src_loc)/ui/effects/ripple_animation.cpp
<(src_loc)/ui/effects/ripple_animation.h
<(src_loc)/ui/effects/round_checkbox.cpp
<(src_loc)/ui/effects/round_checkbox.h
<(src_loc)/ui/effects/send_action_animations.cpp
<(src_loc)/ui/effects/send_action_animations.h
<(src_loc)/ui/effects/slide_animation.cpp
<(src_loc)/ui/effects/slide_animation.h
<(src_loc)/ui/effects/widget_fade_wrap.cpp
<(src_loc)/ui/effects/widget_fade_wrap.h
<(src_loc)/ui/effects/widget_slide_wrap.cpp
<(src_loc)/ui/effects/widget_slide_wrap.h
<(src_loc)/ui/style/style_core.cpp
<(src_loc)/ui/style/style_core.h
<(src_loc)/ui/style/style_core_color.cpp
<(src_loc)/ui/style/style_core_color.h
<(src_loc)/ui/style/style_core_font.cpp
<(src_loc)/ui/style/style_core_font.h
<(src_loc)/ui/style/style_core_icon.cpp
<(src_loc)/ui/style/style_core_icon.h
<(src_loc)/ui/style/style_core_types.cpp
<(src_loc)/ui/style/style_core_types.h
<(src_loc)/ui/text/text.cpp
<(src_loc)/ui/text/text.h
<(src_loc)/ui/text/text_block.cpp
<(src_loc)/ui/text/text_block.h
<(src_loc)/ui/text/text_entity.cpp
<(src_loc)/ui/text/text_entity.h
<(src_loc)/ui/toast/toast.cpp
<(src_loc)/ui/toast/toast.h
<(src_loc)/ui/toast/toast_manager.cpp
<(src_loc)/ui/toast/toast_manager.h
<(src_loc)/ui/toast/toast_widget.cpp
<(src_loc)/ui/toast/toast_widget.h
<(src_loc)/ui/widgets/buttons.cpp
<(src_loc)/ui/widgets/buttons.h
<(src_loc)/ui/widgets/checkbox.cpp
<(src_loc)/ui/widgets/checkbox.h
<(src_loc)/ui/widgets/continuous_sliders.cpp
<(src_loc)/ui/widgets/continuous_sliders.h
<(src_loc)/ui/widgets/discrete_sliders.cpp
<(src_loc)/ui/widgets/discrete_sliders.h
<(src_loc)/ui/widgets/dropdown_menu.cpp
<(src_loc)/ui/widgets/dropdown_menu.h
<(src_loc)/ui/widgets/inner_dropdown.cpp
<(src_loc)/ui/widgets/inner_dropdown.h
<(src_loc)/ui/widgets/input_fields.cpp
<(src_loc)/ui/widgets/input_fields.h
<(src_loc)/ui/widgets/labels.cpp
<(src_loc)/ui/widgets/labels.h
<(src_loc)/ui/widgets/menu.cpp
<(src_loc)/ui/widgets/menu.h
<(src_loc)/ui/widgets/multi_select.cpp
<(src_loc)/ui/widgets/multi_select.h
<(src_loc)/ui/widgets/popup_menu.cpp
<(src_loc)/ui/widgets/popup_menu.h
<(src_loc)/ui/widgets/scroll_area.cpp
<(src_loc)/ui/widgets/scroll_area.h
<(src_loc)/ui/widgets/shadow.cpp
<(src_loc)/ui/widgets/shadow.h
<(src_loc)/ui/widgets/tooltip.cpp
<(src_loc)/ui/widgets/tooltip.h
<(src_loc)/ui/abstract_button.cpp
<(src_loc)/ui/abstract_button.h
<(src_loc)/ui/animation.cpp
<(src_loc)/ui/animation.h
<(src_loc)/ui/countryinput.cpp
<(src_loc)/ui/countryinput.h
<(src_loc)/ui/emoji_config.cpp
<(src_loc)/ui/emoji_config.h
<(src_loc)/ui/images.cpp
<(src_loc)/ui/images.h
<(src_loc)/ui/special_buttons.cpp
<(src_loc)/ui/special_buttons.h
<(src_loc)/ui/twidget.cpp
<(src_loc)/ui/twidget.h
<(src_loc)/window/window_controller.cpp
<(src_loc)/window/window_controller.h
<(src_loc)/window/main_window.cpp
<(src_loc)/window/main_window.h
<(src_loc)/window/notifications_manager.cpp
<(src_loc)/window/notifications_manager.h
<(src_loc)/window/notifications_manager_default.cpp
<(src_loc)/window/notifications_manager_default.h
<(src_loc)/window/notifications_utilities.cpp
<(src_loc)/window/notifications_utilities.h
<(src_loc)/window/player_wrap_widget.cpp
<(src_loc)/window/player_wrap_widget.h
<(src_loc)/window/section_memento.h
<(src_loc)/window/section_widget.cpp
<(src_loc)/window/section_widget.h
<(src_loc)/window/top_bar_widget.cpp
<(src_loc)/window/top_bar_widget.h
<(src_loc)/window/window_main_menu.cpp
<(src_loc)/window/window_main_menu.h
<(src_loc)/window/window_slide_animation.cpp
<(src_loc)/window/window_slide_animation.h
<(src_loc)/window/window_title.h
<(src_loc)/window/themes/window_theme.cpp
<(src_loc)/window/themes/window_theme.h
<(src_loc)/window/themes/window_theme_editor.cpp
<(src_loc)/window/themes/window_theme_editor.h
<(src_loc)/window/themes/window_theme_editor_block.cpp
<(src_loc)/window/themes/window_theme_editor_block.h
<(src_loc)/window/themes/window_theme_preview.cpp
<(src_loc)/window/themes/window_theme_preview.h
<(src_loc)/window/themes/window_theme_warning.cpp
<(src_loc)/window/themes/window_theme_warning.h
<(src_loc)/apiwrap.cpp
<(src_loc)/apiwrap.h
<(src_loc)/app.cpp
<(src_loc)/app.h
<(src_loc)/application.cpp
<(src_loc)/application.h
<(src_loc)/auth_session.cpp
<(src_loc)/auth_session.h
<(src_loc)/autoupdater.cpp
<(src_loc)/autoupdater.h
<(src_loc)/config.h
<(src_loc)/countries.h
<(src_loc)/facades.cpp
<(src_loc)/facades.h
<(src_loc)/layerwidget.cpp
<(src_loc)/layerwidget.h
<(src_loc)/layout.cpp
<(src_loc)/layout.h
<(src_loc)/logs.cpp
<(src_loc)/logs.h
<(src_loc)/main.cpp
<(src_loc)/mainwidget.cpp
<(src_loc)/mainwidget.h
<(src_loc)/mainwindow.cpp
<(src_loc)/mainwindow.h
<(src_loc)/mediaview.cpp
<(src_loc)/mediaview.h
<(src_loc)/messenger.cpp
<(src_loc)/messenger.h
<(src_loc)/observer_peer.cpp
<(src_loc)/observer_peer.h
<(src_loc)/overviewwidget.cpp
<(src_loc)/overviewwidget.h
<(src_loc)/passcodewidget.cpp
<(src_loc)/passcodewidget.h
<(src_loc)/qt_static_plugins.cpp
<(src_loc)/settings.cpp
<(src_loc)/settings.h
<(src_loc)/shortcuts.cpp
<(src_loc)/shortcuts.h
<(src_loc)/stdafx.cpp
<(src_loc)/stdafx.h
<(src_loc)/structs.cpp
<(src_loc)/structs.h
<(emoji_suggestions_loc)/emoji_suggestions.cpp
<(emoji_suggestions_loc)/emoji_suggestions.h
platforms: !win
<(minizip_loc)/crypt.h
<(minizip_loc)/ioapi.c
<(minizip_loc)/ioapi.h
<(minizip_loc)/zip.c
<(minizip_loc)/zip.h
<(minizip_loc)/unzip.c
<(minizip_loc)/unzip.h
platforms: mac
<(sp_media_key_tap_loc)/SPMediaKeyTap.m
<(sp_media_key_tap_loc)/SPMediaKeyTap.h
<(sp_media_key_tap_loc)/SPInvocationGrabbing/NSObject+SPInvocationGrabbing.m
<(sp_media_key_tap_loc)/SPInvocationGrabbing/NSObject+SPInvocationGrabbing.h

91
Telegram/gyp/telegram_win.gypi
View File

@ -1,91 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'conditions': [[ 'build_win', {
'msvs_precompiled_source': '<(src_loc)/stdafx.cpp',
'msvs_precompiled_header': '<(src_loc)/stdafx.h',
'msbuild_toolset': 'v141',
'sources': [
'<(res_loc)/winrc/Telegram.rc',
],
'library_dirs': [
'<(libs_loc)/ffmpeg',
],
'libraries': [
'-llibeay32',
'-lssleay32',
'-lCrypt32',
'-lzlibstat',
'-lLzmaLib',
'-lUxTheme',
'-lDbgHelp',
'-lOpenAL32',
'-lcommon',
'-lopus',
'windows/common',
'windows/handler/exception_handler',
'windows/crash_generation/crash_generation_client',
],
'msvs_settings': {
'VCLinkerTool': {
'AdditionalOptions': [
'libavformat/libavformat.a',
'libavcodec/libavcodec.a',
'libavutil/libavutil.a',
'libswresample/libswresample.a',
'libswscale/libswscale.a',
],
},
},
'configurations': {
'Debug': {
'include_dirs': [
'<(libs_loc)/openssl/Debug/include',
],
'library_dirs': [
'<(libs_loc)/openssl/Debug/lib',
'<(libs_loc)/lzma/C/Util/LzmaLib/Debug',
'<(libs_loc)/opus/win32/VS2015/Win32/Debug',
'<(libs_loc)/openal-soft/build/Debug',
'<(libs_loc)/zlib/contrib/vstudio/vc14/x86/ZlibStatDebug',
'<(libs_loc)/breakpad/src/out/Debug/obj/client',
],
},
'Release': {
'include_dirs': [
'<(libs_loc)/openssl/Release/include',
],
'library_dirs': [
'<(libs_loc)/openssl/Release/lib',
'<(libs_loc)/lzma/C/Util/LzmaLib/Release',
'<(libs_loc)/opus/win32/VS2015/Win32/Release',
'<(libs_loc)/openal-soft/build/Release',
'<(libs_loc)/zlib/contrib/vstudio/vc14/x86/ZlibStatReleaseWithoutAsm',
'<(libs_loc)/breakpad/src/out/Release/obj/client',
],
},
},
}], [ 'build_uwp', {
'defines': [
'TDESKTOP_DISABLE_AUTOUPDATE',
'OS_WIN_STORE',
]
}]],
}

34
Telegram/gyp/tests/common_test.gypi
View File

@ -1,34 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'../common_executable.gypi',
'../qt.gypi',
],
'include_dirs': [
'<(src_loc)',
'<(submodules_loc)/GSL/include',
'<(submodules_loc)/variant/include',
'<(submodules_loc)/Catch/include'
],
'sources': [
'<(src_loc)/base/tests_main.cpp',
],
}

79
Telegram/gyp/tests/list_tests.py
View File

@ -1,79 +0,0 @@
'''
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014 John Preston, https://desktop.telegram.org
'''
from __future__ import print_function
import sys
import os
import re
import time
import codecs
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
sys.exit(1)
my_path = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/')
next_input_path = 0
input_path = ''
write_sources = 0
next_self = 1
for arg in sys.argv:
if next_self != 0:
next_self = 0
continue
if arg == '--sources':
write_sources = 1
continue
if arg == '--input':
next_input_path = 1
continue
elif next_input_path == 1:
next_input_path = 0
input_path = arg
continue
tests_names = []
if input_path != '':
if not os.path.isfile(input_path):
eprint('Input path not found.')
else:
with open(input_path, 'r') as f:
for line in f:
test_name = line.strip()
if test_name[0:2] != '//' and test_name != '':
tests_names.append(test_name)
if write_sources != 0:
tests_path = my_path + '/';
if not os.path.isdir(tests_path):
os.mkdir(tests_path)
for test_name in tests_names:
test_path = tests_path + test_name + '.test'
if not os.path.isfile(test_path):
with open(test_path, 'w') as out:
out.write('1')
print(test_name + '.test')
else:
for test_name in tests_names:
print(test_name)

86
Telegram/gyp/tests/tests.gyp
View File

@ -1,86 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'../common.gypi',
],
'variables': {
'libs_loc': '../../../../Libraries',
'src_loc': '../../SourceFiles',
'submodules_loc': '../../ThirdParty',
'mac_target': '10.10',
'list_tests_command': 'python <(DEPTH)/tests/list_tests.py --input <(DEPTH)/tests/tests_list.txt',
},
'targets': [{
'target_name': 'tests',
'type': 'none',
'includes': [
'../common.gypi',
],
'dependencies': [
'<!@(<(list_tests_command))',
],
'sources': [
'<!@(<(list_tests_command) --sources)',
],
'rules': [{
'rule_name': 'run_tests',
'extension': 'test',
'inputs': [
'<(PRODUCT_DIR)/<(RULE_INPUT_ROOT)<(exe_ext)',
],
'outputs': [
'<(SHARED_INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).timestamp',
],
'action': [
'<(PRODUCT_DIR)/<(RULE_INPUT_ROOT)<(exe_ext)',
'--touch', '<(SHARED_INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).timestamp',
],
'message': 'Running <(RULE_INPUT_ROOT)..',
}]
}, {
'target_name': 'tests_flat_map',
'includes': [
'common_test.gypi',
],
'sources': [
'<(src_loc)/base/flat_map.h',
'<(src_loc)/base/flat_map_tests.cpp',
],
}, {
'target_name': 'tests_flat_set',
'includes': [
'common_test.gypi',
],
'sources': [
'<(src_loc)/base/flat_set.h',
'<(src_loc)/base/flat_set_tests.cpp',
],
}, {
'target_name': 'tests_flags',
'includes': [
'common_test.gypi',
],
'sources': [
'<(src_loc)/base/flags.h',
'<(src_loc)/base/flags_tests.cpp',
],
}],
}

3
Telegram/gyp/tests/tests_list.txt
View File

@ -1,3 +0,0 @@
tests_flat_map
tests_flat_set
tests_flags

184
Telegram/gyp/update_dependent.py
View File

@ -1,184 +0,0 @@
'''
This file is part of Telegram Desktop,
the official desktop version of Telegram messaging app, see https://telegram.org
Telegram Desktop is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
It is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
In addition, as a special exception, the copyright holders give permission
to link the code of portions of this program with the OpenSSL library.
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
Copyright (c) 2014 John Preston, https://desktop.telegram.org
'''
from __future__ import print_function
import sys
import os
import re
import time
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
sys.exit(1)
my_path = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/')
def get_qrc_dependencies(file_path):
global one_modified
dependencies = {}
if not os.path.isfile(file_path):
eprint('File not found: ' + file_path)
dir_name = os.path.dirname(file_path).replace('\\', '/')
with open(file_path) as f:
for line in f:
file_match = re.match('^\s*<file(\s[^>]*)?>([^<]+)</file>', line)
if file_match:
full_path = dir_name + '/' + file_match.group(2)
dependencies[full_path] = 1
return dependencies
def list_qrc_dependencies(file_path):
global one_modified
dependencies = get_qrc_dependencies(file_path)
for path in dependencies:
print(path)
sys.exit(0)
one_modified = 0
def handle_qrc_dependencies(file_path):
global one_modified
dependencies = get_qrc_dependencies(file_path)
file_modified = os.path.getmtime(file_path)
latest_modified = file_modified
for path in dependencies:
if os.path.isfile(path):
dependency_modified = os.path.getmtime(path)
if latest_modified < dependency_modified:
latest_modified = dependency_modified
else:
eprint('File not found: ' + path)
if file_modified < latest_modified:
os.utime(file_path, None);
one_modified = 1
def get_direct_style_dependencies(file_path):
dependencies = {}
dependencies[file_path] = 1
if not os.path.isfile(file_path):
eprint('File not found: ' + file_path)
with open(file_path) as f:
for line in f:
using_match = re.match('^\s*using "([^"]+)"', line)
if using_match:
path = using_match.group(1)
found = 0
for include_dir in include_dirs:
full_path = include_dir + '/' + path
if os.path.isfile(full_path):
try:
if dependencies[full_path]:
eprint('Cyclic dependencies: ' + full_path)
except KeyError:
dependencies[full_path] = 1
found = 1
break
if found != 1:
eprint('File not found: ' + path)
return dependencies
include_dirs = []
def handle_style_dependencies(file_path):
global one_modified
all_dependencies = {}
all_dependencies[file_path] = 1
added_from = {}
while len(added_from) != len(all_dependencies):
for dependency in all_dependencies:
try:
if added_from[dependency]:
continue
except KeyError:
added_from[dependency] = 1
add = get_direct_style_dependencies(dependency)
for new_dependency in add:
all_dependencies[new_dependency] = 1
break
file_modified = os.path.getmtime(file_path)
latest_modified = file_modified
for path in all_dependencies:
if path != file_path:
dependency_modified = os.path.getmtime(path)
if latest_modified < dependency_modified:
latest_modified = dependency_modified
if file_modified < latest_modified:
os.utime(file_path, None);
one_modified = 1
file_paths = []
request = ''
output_file = ''
next_include_dir = 0
next_output_file = 0
next_self = 1
for arg in sys.argv:
if next_self != 0:
next_self = 0
continue
if arg == '--styles' or arg == '--qrc_list' or arg == '--qrc':
if request == '':
request = arg[2:]
else:
eprint('Only one request required.')
continue
if next_include_dir != 0:
next_include_dir = 0
include_dirs.append(arg)
continue
if next_output_file != 0:
next_output_file = 0
output_file = arg
continue
include_dir_match = re.match(r'^\-I(.*)$', arg)
if include_dir_match:
include_dir = include_dir_match.group(1)
if include_dir == '':
next_include_dir = 1
else:
include_dirs.append(include_dir)
continue
output_match = re.match(r'^-o(.*)$', arg)
if output_match:
output_file = output_match.group(1)
if output_file == '':
next_output_file = 1
continue
file_paths.append(arg)
if request == 'styles':
for file_path in file_paths:
handle_style_dependencies(file_path)
elif request == 'qrc':
for file_path in file_paths:
handle_qrc_dependencies(file_path)
elif request == 'qrc_list':
for file_path in file_paths:
list_qrc_dependencies(file_path)
else:
eprint('Request required.')
if not os.path.isfile(output_file):
with open(output_file, "w") as f:
f.write('1')
elif one_modified != 0:
os.utime(output_file, None);

166
Telegram/gyp/utils.gyp
View File

@ -1,166 +0,0 @@
# This file is part of Telegram Desktop,
# the official desktop version of Telegram messaging app, see https://telegram.org
#
# Telegram Desktop is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# It is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# In addition, as a special exception, the copyright holders give permission
# to link the code of portions of this program with the OpenSSL library.
#
# Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
# Copyright (c) 2014 John Preston, https://desktop.telegram.org
{
'includes': [
'common.gypi',
],
'targets': [{
'target_name': 'Updater',
'variables': {
'libs_loc': '../../../Libraries',
'src_loc': '../SourceFiles',
'res_loc': '../Resources',
},
'includes': [
'common_executable.gypi',
],
'include_dirs': [
'<(src_loc)',
],
'sources': [
'<(src_loc)/_other/updater.cpp',
'<(src_loc)/_other/updater.h',
'<(src_loc)/_other/updater_linux.cpp',
'<(src_loc)/_other/updater_osx.m',
],
'conditions': [
[ 'build_win', {
'sources': [
'<(res_loc)/winrc/Updater.rc',
],
}],
[ '"<(build_linux)" != "1"', {
'sources!': [
'<(src_loc)/_other/updater_linux.cpp',
],
}],
[ '"<(build_mac)" != "1"', {
'sources!': [
'<(src_loc)/_other/updater_osx.m',
],
}],
[ '"<(build_win)" != "1"', {
'sources!': [
'<(src_loc)/_other/updater.cpp',
],
}],
],
}, {
'target_name': 'Packer',
'variables': {
'libs_loc': '../../../Libraries',
'src_loc': '../SourceFiles',
'mac_target': '10.10',
},
'includes': [
'common_executable.gypi',
'qt.gypi',
],
'conditions': [
[ 'build_win', {
'libraries': [
'libeay32',
'ssleay32',
'Crypt32',
'zlibstat',
'LzmaLib',
],
}],
[ 'build_linux', {
'libraries': [
'ssl',
'crypto',
'lzma',
],
}],
[ 'build_mac', {
'include_dirs': [
'<(libs_loc)/openssl-xcode/include'
],
'library_dirs': [
'<(libs_loc)/openssl-xcode',
],
'xcode_settings': {
'OTHER_LDFLAGS': [
'-lssl',
'-lcrypto',
'-llzma',
],
},
}],
],
'include_dirs': [
'<(src_loc)',
'<(libs_loc)/lzma/C',
'<(libs_loc)/zlib',
],
'sources': [
'<(src_loc)/_other/packer.cpp',
'<(src_loc)/_other/packer.h',
],
'configurations': {
'Debug': {
'conditions': [
[ 'build_win', {
'include_dirs': [
'<(libs_loc)/openssl/Debug/include',
],
'library_dirs': [
'<(libs_loc)/openssl/Debug/lib',
'<(libs_loc)/lzma/C/Util/LzmaLib/Debug',
'<(libs_loc)/zlib/contrib/vstudio/vc14/x86/ZlibStatDebug',
],
}, {
'include_dirs': [
'/usr/local/include',
'<(libs_loc)/openssl-xcode/include'
],
'library_dirs': [
'/usr/local/lib',
],
}]
],
},
'Release': {
'conditions': [
[ 'build_win', {
'include_dirs': [
'<(libs_loc)/openssl/Release/include',
],
'library_dirs': [
'<(libs_loc)/openssl/Release/lib',
'<(libs_loc)/lzma/C/Util/LzmaLib/Release',
'<(libs_loc)/zlib/contrib/vstudio/vc14/x86/ZlibStatReleaseWithoutAsm',
],
}, {
'include_dirs': [
'/usr/local/include',
'<(libs_loc)/openssl-xcode/include'
],
'library_dirs': [
'/usr/local/lib',
],
}]
],
},
},
}],
}

167
docs/building-msvc.md
View File

@ -1,167 +0,0 @@
# Build instructions for Visual Studio 2017
- [Prepare folder](#prepare-folder)
- [Install third party software](#install-third-party-software)
- [Clone source code and prepare libraries](#clone-source-code-and-prepare-libraries)
- [Build the project](#build-the-project)
- [Qt Visual Studio Tools](#qt-visual-studio-tools)
## Prepare folder
Choose an empty folder for the future build, for example **D:\\TBuild**. It will be named ***BuildPath*** in the rest of this document. Create two folders there, ***BuildPath*\\ThirdParty** and ***BuildPath*\\Libraries**
All commands (if not stated otherwise) will be launched from **x86 Native Tools Command Prompt for VS 2017.bat** (should be in **Start Menu > Visual Studio 2017** menu folder). Pay attention not to use any other Command Prompt.
## Install third party software
* Download **ActivePerl** installer from [https://www.activestate.com/activeperl/downloads](https://www.activestate.com/activeperl/downloads) and install to ***BuildPath*\\ThirdParty\\Perl**
* Download **NASM** installer from [http://www.nasm.us](http://www.nasm.us) and install to ***BuildPath*\\ThirdParty\\NASM**
* Download **Yasm** executable from [http://yasm.tortall.net/Download.html](http://yasm.tortall.net/Download.html), rename to *yasm.exe* and put to ***BuildPath*\\ThirdParty\\yasm**
* Download **MSYS2** installer from [http://www.msys2.org/](http://www.msys2.org/) and install to ***BuildPath*\\ThirdParty\\msys64**
* Download **jom** archive from [http://download.qt.io/official_releases/jom/jom.zip](http://download.qt.io/official_releases/jom/jom.zip) and unpack to ***BuildPath*\\ThirdParty\\jom**
* Download **Python 2.7** installer from [https://www.python.org/downloads/](https://www.python.org/downloads/) and install to ***BuildPath*\\ThirdParty\\Python27**
* Download **CMake** installer from [https://cmake.org/download/](https://cmake.org/download/) and install to ***BuildPath*\\ThirdParty\\cmake**
* Download **Ninja** executable from [https://github.com/ninja-build/ninja/releases/download/v1.7.2/ninja-win.zip](https://github.com/ninja-build/ninja/releases/download/v1.7.2/ninja-win.zip) and unpack to ***BuildPath*\\ThirdParty\\Ninja**
Open **x86 Native Tools Command Prompt for VS 2017.bat**, go to ***BuildPath*** and run
cd ThirdParty
git clone https://chromium.googlesource.com/external/gyp
cd gyp
git checkout a478c1ab51
cd ..\..
Add **GYP** and **Ninja** to your PATH:
* Open **Control Panel** -> **System** -> **Advanced system settings**
* Press **Environment Variables...**
* Select **Path**
* Press **Edit**
* Add ***BuildPath*\\ThirdParty\\gyp** value
* Add ***BuildPath*\\ThirdParty\\Ninja** value
## Clone source code and prepare libraries
Open **x86 Native Tools Command Prompt for VS 2017.bat**, go to ***BuildPath*** and run
SET PATH=%cd%\ThirdParty\Perl\bin;%cd%\ThirdParty\Python27;%cd%\ThirdParty\NASM;%cd%\ThirdParty\jom;%cd%\ThirdParty\cmake\bin;%cd%\ThirdParty\yasm;%PATH%
git clone --recursive https://github.com/telegramdesktop/tdesktop.git
mkdir Libraries
cd Libraries
git clone https://github.com/telegramdesktop/lzma.git
cd lzma\C\Util\LzmaLib
msbuild LzmaLib.sln /property:Configuration=Debug
msbuild LzmaLib.sln /property:Configuration=Release
cd ..\..\..\..
git clone https://github.com/openssl/openssl.git
cd openssl
git checkout OpenSSL_1_0_1-stable
perl Configure no-shared --prefix=%cd%\Release --openssldir=%cd%\Release VC-WIN32
ms\do_ms
nmake -f ms\nt.mak
nmake -f ms\nt.mak install
xcopy tmp32\lib.pdb Release\lib\
nmake -f ms\nt.mak clean
perl Configure no-shared --prefix=%cd%\Debug --openssldir=%cd%\Debug debug-VC-WIN32
ms\do_ms
nmake -f ms\nt.mak
nmake -f ms\nt.mak install
xcopy tmp32.dbg\lib.pdb Debug\lib\
cd ..
git clone https://github.com/telegramdesktop/zlib.git
cd zlib
git checkout tdesktop
cd contrib\vstudio\vc14
msbuild zlibstat.vcxproj /property:Configuration=Debug
msbuild zlibstat.vcxproj /property:Configuration=ReleaseWithoutAsm
cd ..\..\..\..
git clone git://repo.or.cz/openal-soft.git
cd openal-soft
git checkout 18bb46163af
cd build
cmake -G "Visual Studio 15 2017" -D LIBTYPE:STRING=STATIC -D FORCE_STATIC_VCRT:STRING=ON ..
msbuild OpenAL32.vcxproj /property:Configuration=Debug
msbuild OpenAL32.vcxproj /property:Configuration=Release
cd ..\..
git clone https://github.com/google/breakpad
cd breakpad
git checkout a1dbcdcb43
git apply ../../tdesktop/Telegram/Patches/breakpad.diff
cd src
git clone https://github.com/google/googletest testing
cd client\windows
set GYP_MSVS_VERSION=2017
gyp --no-circular-check breakpad_client.gyp --format=ninja
cd ..\..
ninja -C out/Debug common crash_generation_client exception_handler
ninja -C out/Release common crash_generation_client exception_handler
cd ..\..
git clone https://github.com/telegramdesktop/opus.git
cd opus
git checkout tdesktop
cd win32\VS2015
msbuild opus.sln /property:Configuration=Debug /property:Platform="Win32"
msbuild opus.sln /property:Configuration=Release /property:Platform="Win32"
cd ..\..\..\..
SET PATH_BACKUP_=%PATH%
SET PATH=%cd%\ThirdParty\msys64\usr\bin;%PATH%
cd Libraries
git clone https://github.com/FFmpeg/FFmpeg.git ffmpeg
cd ffmpeg
git checkout release/3.2
set CHERE_INVOKING=enabled_from_arguments
set MSYS2_PATH_TYPE=inherit
bash --login ../../tdesktop/Telegram/Patches/build_ffmpeg_win.sh
SET PATH=%PATH_BACKUP_%
cd ..
git clone git://code.qt.io/qt/qt5.git qt5_6_2
cd qt5_6_2
perl init-repository --module-subset=qtbase,qtimageformats
git checkout v5.6.2
cd qtimageformats
git checkout v5.6.2
cd ..\qtbase
git checkout v5.6.2
git apply ../../../tdesktop/Telegram/Patches/qtbase_5_6_2.diff
cd ..
configure -debug-and-release -force-debug-info -opensource -confirm-license -static -I "%cd%\..\openssl\Release\include" -no-opengl -openssl-linked OPENSSL_LIBS_DEBUG="%cd%\..\openssl\Debug\lib\ssleay32.lib %cd%\..\openssl\Debug\lib\libeay32.lib" OPENSSL_LIBS_RELEASE="%cd%\..\openssl\Release\lib\ssleay32.lib %cd%\..\openssl\Release\lib\libeay32.lib" -mp -nomake examples -nomake tests -platform win32-msvc2015
jom -j4
jom -j4 install
cd ..
cd ../tdesktop/Telegram
gyp\refresh.bat
## Build the project
If you want to pass a build define (like `TDESKTOP_DISABLE_AUTOUPDATE` or `TDESKTOP_DISABLE_NETWORK_PROXY`), call `set TDESKTOP_BUILD_DEFINES=TDESKTOP_DISABLE_AUTOUPDATE,TDESKTOP_DISABLE_NETWORK_PROXY,...` (comma seperated string)
After, call **gyp\refresh.bat** once again.
* Open ***BuildPath*\\tdesktop\\Telegram\\Telegram.sln** in Visual Studio 2017
* Select Telegram project and press Build > Build Telegram (Debug and Release configurations)
* The result Telegram.exe will be located in **D:\TBuild\tdesktop\out\Debug** (and **Release**)
### Qt Visual Studio Tools
For better debugging you may want to install Qt Visual Studio Tools:
* Open **Tools** -> **Extensions and Updates...**
* Go to **Online** tab
* Search for **Qt**
* Install **Qt Visual Studio Tools** extension

137
docs/building-qmake.md
View File

@ -1,137 +0,0 @@
Building via qmake
==================
**NB** These are outdated, please refer to [Building using GYP/CMake][cmake] instructions.
The following commands assume the following environment variables are set:
* `$srcdir`: The directory into which the source has been downloaded and
unpacked.
* `_qtver`: The Qt version being used (eg: `5.6.2`).
* `$pkgdir`: The directory into which installable files are places. This is
`/` for local installations, or can be different directory when preparing a
redistributable package.
Either set them accordingly, or replace them in the below commands as desired.
The following sources should be downloaded and unpacked into `$srcdir`:
* This repository (either `master` or a specific tag).
* `git clone git://code.qt.io/qt/qt5.git`
* `git clone git+https://chromium.googlesource.com/breakpad/breakpad breakpad`
* `git clone git+https://chromium.googlesource.com/linux-syscall-support breakpad-lss`
* telegramdesktop.desktop (The intention is to include this file inside the
source package at some point):
`https://aur.archlinux.org/cgit/aur.git/plain/telegramdesktop.desktop?h=telegram-desktop`
* tg.protocol: `https://aur.archlinux.org/cgit/aur.git/plain/tg.protocol?h=telegram-desktop`
Preparation
-----------
cd "$srcdir/tdesktop"
mkdir -p "$srcdir/Libraries"
local qt_patch_file="$srcdir/tdesktop/Telegram/Patches/qtbase_${_qtver//./_}.diff"
local qt_dir="$srcdir/Libraries/qt${_qtver//./_}"
if [ "$qt_patch_file" -nt "$qt_dir" ]; then
rm -rf "$qt_dir"
git clone git://code.qt.io/qt/qt5.git
cd "$qt_dir"
perl init-repository --module-subset=qtbase,qtimageformats
git checkout v$_qtver
cd qtimageformats
git checkout v$_qtver
cd ../qtbase
git checkout v$_qtver
git apply "$qt_patch_file"
fi
if [ ! -h "$srcdir/Libraries/breakpad" ]; then
ln -s "$srcdir/breakpad" "$srcdir/Libraries/breakpad"
ln -s "$srcdir/breakpad-lss" "$srcdir/Libraries/breakpad/src/third_party/lss"
fi
sed -i 's/CUSTOM_API_ID//g' "$srcdir/tdesktop/Telegram/Telegram.pro"
(
echo "DEFINES += TDESKTOP_DISABLE_AUTOUPDATE"
echo "DEFINES += TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME"
) >> "$srcdir/tdesktop/Telegram/Telegram.pro"
Building
--------
# Build patched Qt
cd "$qtdir"
./configure -prefix "$srcdir/qt" -release -opensource -confirm-license -qt-zlib \
-qt-libpng -qt-libjpeg -qt-freetype -qt-harfbuzz -qt-pcre -qt-xcb \
-qt-xkbcommon-x11 -no-opengl -no-gtkstyle -static -nomake examples -nomake tests
make module-qtbase module-qtimageformats
make module-qtbase-install_subtargets module-qtimageformats-install_subtargets
export PATH="$srcdir/qt/bin:$PATH"
# Build breakpad
cd "$srcdir/Libraries/breakpad"
./configure
make
# Build codegen_style
mkdir -p "$srcdir/tdesktop/Linux/obj/codegen_style/Debug"
cd "$srcdir/tdesktop/Linux/obj/codegen_style/Debug"
qmake CONFIG+=debug ../../../../Telegram/build/qmake/codegen_style/codegen_style.pro
make
# Build codegen_numbers
mkdir -p "$srcdir/tdesktop/Linux/obj/codegen_numbers/Debug"
cd "$srcdir/tdesktop/Linux/obj/codegen_numbers/Debug"
qmake CONFIG+=debug ../../../../Telegram/build/qmake/codegen_numbers/codegen_numbers.pro
make
# Build MetaLang
mkdir -p "$srcdir/tdesktop/Linux/DebugIntermediateLang"
cd "$srcdir/tdesktop/Linux/DebugIntermediateLang"
qmake CONFIG+=debug "../../Telegram/MetaLang.pro"
make
# Build Telegram Desktop
mkdir -p "$srcdir/tdesktop/Linux/ReleaseIntermediate"
cd "$srcdir/tdesktop/Linux/ReleaseIntermediate"
qmake CONFIG+=release "../../Telegram/Telegram.pro"
make
Installation
------------
install -dm755 "$pkgdir/usr/bin"
install -m755 "$srcdir/tdesktop/Linux/Release/Telegram" "$pkgdir/usr/bin/telegram-desktop"
install -d "$pkgdir/usr/share/applications"
install -m644 "$srcdir/telegramdesktop.desktop" "$pkgdir/usr/share/applications/telegramdesktop.desktop"
install -d "$pkgdir/usr/share/kde4/services"
install -m644 "$srcdir/tg.protocol" "$pkgdir/usr/share/kde4/services/tg.protocol"
local icon_size icon_dir
for icon_size in 16 32 48 64 128 256 512; do
icon_dir="$pkgdir/usr/share/icons/hicolor/${icon_size}x${icon_size}/apps"
install -d "$icon_dir"
install -m644 "$srcdir/tdesktop/Telegram/SourceFiles/art/icon${icon_size}.png" "$icon_dir/telegram-desktop.png"
done
Notes
-----
These instructions are based on the [ArchLinux package][arch-package] for
telegram-desktop.
In case these instructions are at some point out of date, the above may serve
as an update reference.
[arch-package]: https://aur.archlinux.org/packages/telegram-desktop/
[cmake]: building-cmake.md

193
docs/building-qtcreator.md
View File

@ -1,193 +0,0 @@
## Build instructions for Qt Creator 3.5.1 under Ubuntu 12.04
**NB** These are outdated, please refer to [Building using GYP/CMake][cmake] instructions.
### Prepare
* Install git by command **sudo apt-get install git** in Terminal
* Install g++ by command **sudo apt-get install g++** in Terminal
* Install Qt Creator from [**Downloads page**](https://www.qt.io/download/)
You need to install g++ version 4.9 manually by such commands
* sudo add-apt-repository ppa:ubuntu-toolchain-r/test
* sudo apt-get update
* sudo apt-get install gcc-4.9 g++-4.9
* sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 21
* sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.9 21
### Prepare folder
Choose a folder for the future build, for example **/home/user/TBuild** There you will have two folders, **Libraries** for third-party libs and **tdesktop** (or **tdesktop-master**) for the app.
### Clone source code
By git – in Terminal go to **/home/user/TBuild** and run
git clone --recursive https://github.com/telegramdesktop/tdesktop.git
### Prepare libraries
Install dev libraries
sudo apt-get install libexif-dev liblzma-dev libz-dev libssl-dev libappindicator-dev libunity-dev
#### zlib 1.2.8
http://www.zlib.net/ > Download [**zlib source code, version 1.2.8, zipfile format**](http://zlib.net/zlib128.zip)
Extract to **/home/user/TBuild/Libraries**
##### Building library
In Terminal go to **/home/user/TBuild/Libraries/zlib-1.2.8** and run:
./configure
make
sudo make install
Install audio libraries
#### Opus codec
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone https://github.com/xiph/opus
cd opus
git checkout v1.2-alpha2
./autogen.sh
./configure
make
sudo make install
#### FFmpeg
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone git://anongit.freedesktop.org/git/libva
cd libva
./autogen.sh --enable-static
make
sudo make install
cd ..
git clone https://github.com/FFmpeg/FFmpeg.git ffmpeg
cd ffmpeg
git checkout release/3.2
sudo apt-get update
sudo apt-get -y --force-yes install autoconf automake build-essential libass-dev libfreetype6-dev libgpac-dev libsdl1.2-dev libtheora-dev libtool libva-dev libvdpau-dev libvorbis-dev libxcb1-dev libxcb-shm0-dev libxcb-xfixes0-dev pkg-config texi2html zlib1g-dev
sudo apt-get install yasm
./configure --prefix=/usr/local --disable-programs --disable-doc --disable-everything --enable-protocol=file --enable-libopus --enable-decoder=aac --enable-decoder=aac_latm --enable-decoder=aasc --enable-decoder=flac --enable-decoder=gif --enable-decoder=h264 --enable-decoder=h264_vdpau --enable-decoder=mp1 --enable-decoder=mp1float --enable-decoder=mp2 --enable-decoder=mp2float --enable-decoder=mp3 --enable-decoder=mp3adu --enable-decoder=mp3adufloat --enable-decoder=mp3float --enable-decoder=mp3on4 --enable-decoder=mp3on4float --enable-decoder=mpeg4 --enable-decoder=mpeg4_vdpau --enable-decoder=msmpeg4v2 --enable-decoder=msmpeg4v3 --enable-decoder=opus --enable-decoder=pcm_alaw --enable-decoder=pcm_alaw_at --enable-decoder=pcm_f32be --enable-decoder=pcm_f32le --enable-decoder=pcm_f64be --enable-decoder=pcm_f64le --enable-decoder=pcm_lxf --enable-decoder=pcm_mulaw --enable-decoder=pcm_mulaw_at --enable-decoder=pcm_s16be --enable-decoder=pcm_s16be_planar --enable-decoder=pcm_s16le --enable-decoder=pcm_s16le_planar --enable-decoder=pcm_s24be --enable-decoder=pcm_s24daud --enable-decoder=pcm_s24le --enable-decoder=pcm_s24le_planar --enable-decoder=pcm_s32be --enable-decoder=pcm_s32le --enable-decoder=pcm_s32le_planar --enable-decoder=pcm_s64be --enable-decoder=pcm_s64le --enable-decoder=pcm_s8 --enable-decoder=pcm_s8_planar --enable-decoder=pcm_u16be --enable-decoder=pcm_u16le --enable-decoder=pcm_u24be --enable-decoder=pcm_u24le --enable-decoder=pcm_u32be --enable-decoder=pcm_u32le --enable-decoder=pcm_u8 --enable-decoder=pcm_zork --enable-decoder=vorbis --enable-decoder=wavpack --enable-decoder=wmalossless --enable-decoder=wmapro --enable-decoder=wmav1 --enable-decoder=wmav2 --enable-decoder=wmavoice --enable-encoder=libopus --enable-hwaccel=h264_vaapi --enable-hwaccel=h264_vdpau --enable-hwaccel=mpeg4_vaapi --enable-hwaccel=mpeg4_vdpau --enable-parser=aac --enable-parser=aac_latm --enable-parser=flac --enable-parser=h264 --enable-parser=mpeg4video --enable-parser=mpegaudio --enable-parser=opus --enable-parser=vorbis --enable-demuxer=aac --enable-demuxer=flac --enable-demuxer=gif --enable-demuxer=h264 --enable-demuxer=mov --enable-demuxer=mp3 --enable-demuxer=ogg --enable-demuxer=wav --enable-muxer=ogg --enable-muxer=opus
make
sudo make install
#### PortAudio 19
[Download portaudio sources](http://www.portaudio.com/archives/pa_stable_v19_20140130.tgz) from **http://www.portaudio.com/download.html**, extract to **/home/user/TBuild/Libraries**, go to **/home/user/TBuild/Libraries/portaudio** and run
./configure
make
sudo make install
#### OpenAL Soft
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone git://repo.or.cz/openal-soft.git
then go to **/home/user/TBuild/Libraries/openal-soft/build** and run
sudo apt-get install cmake
cmake -D LIBTYPE:STRING=STATIC ..
make
sudo make install
#### OpenSSL
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone https://github.com/openssl/openssl
cd openssl
git checkout OpenSSL_1_0_1-stable
./config
make
sudo make install
#### libxkbcommon (required for Fcitx Qt plugin)
In Terminal go to **/home/user/TBuild/Libraries** and run
sudo apt-get install xutils-dev bison python-xcbgen
git clone https://github.com/xkbcommon/libxkbcommon.git
cd libxkbcommon
./autogen.sh --disable-x11
make
sudo make install
#### Qt 5.6.2, slightly patched
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone git://code.qt.io/qt/qt5.git qt5_6_2
cd qt5_6_2
perl init-repository --module-subset=qtbase,qtimageformats
git checkout v5.6.2
cd qtimageformats && git checkout v5.6.2 && cd ..
cd qtbase && git checkout v5.6.2 && cd ..
##### Apply the patch
cd qtbase && git apply ../../../tdesktop/Telegram/Patches/qtbase_5_6_2.diff && cd ..
##### Building library
Install some packages for Qt (see **/home/user/TBuild/Libraries/qt5_6_2/qtbase/src/plugins/platforms/xcb/README**)
sudo apt-get install libxcb1-dev libxcb-image0-dev libxcb-keysyms1-dev libxcb-icccm4-dev libxcb-render-util0-dev libxcb-util0-dev libxrender-dev libasound-dev libpulse-dev libxcb-sync0-dev libxcb-xfixes0-dev libxcb-randr0-dev libx11-xcb-dev libffi-dev
In Terminal go to **/home/user/TBuild/Libraries/qt5_6_2** and there run
./configure -prefix "/usr/local/tdesktop/Qt-5.6.2" -release -force-debug-info -opensource -confirm-license -qt-zlib -qt-libpng -qt-libjpeg -qt-freetype -qt-harfbuzz -qt-pcre -qt-xcb -qt-xkbcommon-x11 -no-opengl -no-gtkstyle -static -openssl-linked -nomake examples -nomake tests
make -j4
sudo make install
building (**make** command) will take really long time.
#### Google Breakpad
In Terminal go to **/home/user/TBuild/Libraries** and run
git clone https://chromium.googlesource.com/breakpad/breakpad
git clone https://chromium.googlesource.com/linux-syscall-support breakpad/src/third_party/lss
cd breakpad
./configure
make
sudo make install
### Building Telegram codegen utilities
In Terminal go to **/home/user/TBuild/tdesktop** and run
mkdir -p Linux/obj/codegen_style/Debug
cd Linux/obj/codegen_style/Debug
/usr/local/tdesktop/Qt-5.6.2/bin/qmake CONFIG+=debug ../../../../Telegram/build/qmake/codegen_style/codegen_style.pro
make
mkdir -p ../../codegen_numbers/Debug
cd ../../codegen_numbers/Debug
/usr/local/tdesktop/Qt-5.6.2/bin/qmake CONFIG+=debug ../../../../Telegram/build/qmake/codegen_numbers/codegen_numbers.pro
make
### Building Telegram Desktop
* Launch Qt Creator, all projects will be taken from **/home/user/TBuild/tdesktop/Telegram**
* Tools > Options > Build & Run > Qt Versions tab > Add > File System /usr/local/tdesktop/Qt-5.6.2/bin/qmake > **Qt 5.6.2 (Qt-5.6.2)** > Apply
* Tools > Options > Build & Run > Kits tab > Desktop (default) > change **Qt version** to **Qt 5.6.2 (Qt-5.6.2)** > Apply
* Open MetaLang.pro, configure project with paths **/home/user/TBuild/tdesktop/Linux/DebugIntermediateLang** and **/home/user/TBuild/tdesktop/Linux/ReleaseIntermediateLang** and build for Debug
* Open Telegram.pro, configure project with paths **/home/user/TBuild/tdesktop/Linux/DebugIntermediate** and **/home/user/TBuild/tdesktop/Linux/ReleaseIntermediate** and build for Debug, if GeneratedFiles are not found click **Run qmake** from **Build** menu and try again
* Open Updater.pro, configure project with paths **/home/user/TBuild/tdesktop/Linux/DebugIntermediateUpdater** and **/home/user/TBuild/tdesktop/Linux/ReleaseIntermediateUpdater** and build for Debug
* Release Telegram build will require removing **CUSTOM_API_ID** definition in Telegram.pro project and may require changing paths in **/home/user/TBuild/tdesktop/Telegram/FixMake.sh** or **/home/user/TBuild/tdesktop/Telegram/FixMake32.sh** for static library linking fix, static linking applies only on second Release build (first uses old Makefile)
[cmake]: building-cmake.md

242
docs/building-xcode-old.md
View File

@ -1,242 +0,0 @@
## Build instructions for Xcode 7.2.1
**NB** These are outdated, please refer to [Building using Xcode][xcode] instructions.
### Prepare folder
Choose a folder for the future build, for example **/Users/user/TBuild** There you will have two folders, **Libraries** for third-party libs and **tdesktop** (or **tdesktop-master**) for the app.
### Clone source code
By git – in Terminal go to **/Users/user/TBuild** and run
git clone --recursive https://github.com/telegramdesktop/tdesktop.git
then go to **/Users/user/TBuild/tdesktop** and run
git checkout dev
#### Prepare latest cmake
Download the [latest sources](https://cmake.org/download/) and unpack to **/Users/user/TBuild/Libraries/macold**
./bootstrap
make -j4
sudo make install
### Prepare libraries
In your build Terminal run
MACOSX_DEPLOYMENT_TARGET=10.6
to set minimal supported OS version to 10.6 for future console builds.
#### custom build of libc++
From **/Users/user/TBuild/Libraries/macold** run
svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm
cd llvm/projects
svn co http://llvm.org/svn/llvm-project/libcxx/trunk libcxx
svn co http://llvm.org/svn/llvm-project/libcxxabi/trunk libcxxabi
cd ../../
mkdir libcxxabi
cd libcxxabi
cmake -G "Unix Makefiles" -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.6 -DCMAKE_BUILD_TYPE:STRING=Release -DLIBCXX_ENABLE_SHARED:BOOL=NO -DCMAKE_INSTALL_PREFIX:PATH=/usr/local/macold -DLLVM_PATH=../llvm -DLIBCXXABI_LIBCXX_PATH=../llvm/projects/libcxx ../llvm/projects/libcxxabi/
make -j4
sudo make install
cd ../
mkdir libcxx
cd libcxx
cmake -G "Unix Makefiles" -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.6 -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr/local/macold -DLIBCXX_ENABLE_SHARED:BOOL=NO -DLIBCXX_CXX_ABI:STRING=libstdc++ -DLIBCXX_CXX_ABI_INCLUDE_PATHS="/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/c++/4.2.1/" -DLLVM_PATH=../llvm/ ../llvm/projects/libcxx/
make -j4
sudo make install
#### zlib
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone https://github.com/telegramdesktop/zlib.git
cd zlib
prefix=/usr/local/macold CFLAGS="-mmacosx-version-min=10.6" LDFLAGS="-mmacosx-version-min=10.6" ./configure
make
sudo make install
#### OpenSSL 1.0.1g
http://www.openssl.org/source/ > Download [**openssl-1.0.1h.tar.gz**](http://www.openssl.org/source/openssl-1.0.1h.tar.gz) (4.3 Mb)
Extract openssl-1.0.1h.tar.gz to **/Users/user/TBuild/Libraries/macold/openssl-1.0.1h**
./Configure --install_prefix=/usr/local/macold darwin64-x86_64-cc -static -mmacosx-version-min=10.6
make build_crypto build_ssl -j4
#### liblzma
http://tukaani.org/xz/ > Download [**xz-5.0.5.tar.gz**](http://tukaani.org/xz/xz-5.0.5.tar.gz)
Extract to **/Users/user/TBuild/Libraries**
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/xz-5.0.5** and there run
./configure
make
sudo make install
#### libexif 0.6.20
Get sources from https://github.com/telegramdesktop/libexif-0.6.20, by git – in Terminal go to **/Users/user/TBuild/Libraries/macold** and run
git clone https://github.com/telegramdesktop/libexif-0.6.20.git
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/macold/libexif-0.6.20** and there run
CFLAGS="-mmacosx-version-min=10.6" CPPFLAGS="-mmacosx-version-min=10.6 -nostdinc++" LDFLAGS="-mmacosx-version-min=10.6" ./configure --prefix=/usr/local/macold
make -j4
sudo make install
#### OpenAL Soft
Get sources by git – in Terminal go to **/Users/user/TBuild/Libraries/macold** and run
git clone git://repo.or.cz/openal-soft.git
to have **/Users/user/TBuild/Libraries/macold/openal-soft/CMakeLists.txt**
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/openal-soft/build** and there run
cmake -DLIBTYPE:STRING=STATIC -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.6 -DCMAKE_INSTALL_PREFIX:STRING=/usr/local/macold ..
make
sudo make install
#### Opus codec
In Terminal go to **/Users/user/TBuild/Libraries/macold** and there run
git clone https://github.com/xiph/opus
cd opus
git checkout v1.2-alpha2
./autogen.sh
CFLAGS="-mmacosx-version-min=10.6" CPPFLAGS="-mmacosx-version-min=10.6" LDFLAGS="-mmacosx-version-min=10.6" ./configure --prefix=/usr/local/macold
make
sudo make install
#### FFmpeg
In Terminal go to **/Users/user/TBuild/Libraries/macold** and run:
git clone https://github.com/FFmpeg/FFmpeg.git ffmpeg
cd ffmpeg
git checkout release/3.2
##### Building libraries
Download [libiconv-1.14](http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.14.tar.gz) from http://www.gnu.org/software/libiconv/#downloading, extract it to **/Users/user/TBuild/Libraries/macold**
In Termianl go to **/Users/user/TBuild/Libraries/macold/libiconv-1.14** and run
CFLAGS="-mmacosx-version-min=10.6" CPPFLAGS="-mmacosx-version-min=10.6 -nostdinc++" LDFLAGS="-mmacosx-version-min=10.6" ./configure --enable-static --prefix=/usr/local/macold
make -j4
sudo make install
Then in Terminal go to **/Users/user/TBuild/Libraries/macold/ffmpeg** and run
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew install automake fdk-aac git lame libass libtool libvorbis libvpx opus sdl shtool texi2html theora wget x264 xvid yasm
CFLAGS=`freetype-config --cflags`
LDFLAGS=`freetype-config --libs`
PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig:/usr/X11/lib/pkgconfig
./configure --prefix=/usr/local/macold --disable-programs --disable-doc --disable-everything --enable-protocol=file --enable-libopus --enable-decoder=aac --enable-decoder=aac_latm --enable-decoder=aasc --enable-decoder=flac --enable-decoder=gif --enable-decoder=h264 --enable-decoder=mp1 --enable-decoder=mp1float --enable-decoder=mp2 --enable-decoder=mp2float --enable-decoder=mp3 --enable-decoder=mp3adu --enable-decoder=mp3adufloat --enable-decoder=mp3float --enable-decoder=mp3on4 --enable-decoder=mp3on4float --enable-decoder=mpeg4 --enable-decoder=msmpeg4v2 --enable-decoder=msmpeg4v3 --enable-decoder=opus --enable-decoder=pcm_alaw --enable-decoder=pcm_alaw_at --enable-decoder=pcm_f32be --enable-decoder=pcm_f32le --enable-decoder=pcm_f64be --enable-decoder=pcm_f64le --enable-decoder=pcm_lxf --enable-decoder=pcm_mulaw --enable-decoder=pcm_mulaw_at --enable-decoder=pcm_s16be --enable-decoder=pcm_s16be_planar --enable-decoder=pcm_s16le --enable-decoder=pcm_s16le_planar --enable-decoder=pcm_s24be --enable-decoder=pcm_s24daud --enable-decoder=pcm_s24le --enable-decoder=pcm_s24le_planar --enable-decoder=pcm_s32be --enable-decoder=pcm_s32le --enable-decoder=pcm_s32le_planar --enable-decoder=pcm_s64be --enable-decoder=pcm_s64le --enable-decoder=pcm_s8 --enable-decoder=pcm_s8_planar --enable-decoder=pcm_u16be --enable-decoder=pcm_u16le --enable-decoder=pcm_u24be --enable-decoder=pcm_u24le --enable-decoder=pcm_u32be --enable-decoder=pcm_u32le --enable-decoder=pcm_u8 --enable-decoder=pcm_zork --enable-decoder=vorbis --enable-decoder=wavpack --enable-decoder=wmalossless --enable-decoder=wmapro --enable-decoder=wmav1 --enable-decoder=wmav2 --enable-decoder=wmavoice --enable-encoder=libopus --enable-parser=aac --enable-parser=aac_latm --enable-parser=flac --enable-parser=h264 --enable-parser=mpeg4video --enable-parser=mpegaudio --enable-parser=opus --enable-parser=vorbis --enable-demuxer=aac --enable-demuxer=flac --enable-demuxer=gif --enable-demuxer=h264 --enable-demuxer=mov --enable-demuxer=mp3 --enable-demuxer=ogg --enable-demuxer=wav --enable-muxer=ogg --enable-muxer=opus --extra-cflags="-mmacosx-version-min=10.6" --extra-cxxflags="-mmacosx-version-min=10.6 -nostdinc++" --extra-ldflags="-mmacosx-version-min=10.6"
make
sudo make install
#### Qt 5.3.2, slightly patched
##### Get the source code
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone git://code.qt.io/qt/qt5.git qt5_3_2
cd qt5_3_2
perl init-repository --module-subset=qtbase,qtimageformats
git checkout v5.3.2
cd qtimageformats && git checkout v5.3.2 && cd ..
cd qtbase && git checkout v5.3.2 && cd ..
##### Apply the patch
From **/Users/user/TBuild/Libraries/macold/qt5_3_2/qtbase**, run:
git apply ../../../../tdesktop/Telegram/Patches/macold/qtbase_5_3_2.diff
From **/Users/user/TBuild/Libraries/macold/qt5_3_2/qtimageformats**, run:
git apply ../../../../tdesktop/Telegram/Patches/macold/qtimageformats_5_3_2.diff
##### Building library
Go to **/Users/user/TBuild/Libraries/macold/qt5_3_2** and run:
OPENSSL_LIBS="/Users/user/TBuild/Libraries/macold/openssl-1.0.1h/libssl.a /Users/user/TBuild/Libraries/macold/openssl-1.0.1h/libcrypto.a" ./configure -prefix "/usr/local/macold/Qt-5.3.2" -debug-and-release -force-debug-info -opensource -confirm-license -static -opengl desktop -openssl-linked -I "/Users/user/TBuild/Libraries/macold/openssl-1.0.1h/include" -nomake examples -nomake tests -platform macx-g++
make -j4
sudo make -j4 install
building (**make** command) will take really long time.
#### Google Crashpad
##### Install gyp
.. the same as modern ..
##### Build crashpad
In Terminal go to **/Users/user/TBuild/Libraries/macold** and run:
git clone https://chromium.googlesource.com/crashpad/crashpad.git
cd crashpad
git checkout feb3aa3923
git apply ../../../tdesktop/Telegram/Patches/macold/crashpad.diff
cd third_party/mini_chromium
git clone https://chromium.googlesource.com/chromium/mini_chromium
cd mini_chromium
git checkout 7c5b0c1ab4
git apply ../../../../../../tdesktop/Telegram/Patches/macold/mini_chromium.diff
cd ../../gtest
git clone https://chromium.googlesource.com/external/github.com/google/googletest gtest
cd gtest
git checkout d62d6c6556
cd ../../../
build/gyp_crashpad.py -Dmac_deployment_target=10.6
ninja -C out/Debug
ninja -C out/Release
#### Prepare GYP
.. the same as modern ..
### Building Telegram Desktop
* Launch Xcode, all projects will be taken from **/Users/user/TBuild/tdesktop/Telegram**
* Open MetaEmoji.xcodeproj and build for Debug (Release optionally)
* Open MetaLang.xcodeproj and build for Debug (Release optionally)
* Open Telegram.xcodeproj and build for Debug
* Build Updater target as well, it is required for Telegram relaunch
* Release Telegram build will require removing **CUSTOM_API_ID** definition in Telegram target settings (Apple LLVM 6.1 - Custom Compiler Flags > Other C / C++ Flags > Release)
[xcode]: building-xcode.md

234
docs/building-xcode.md
View File

@ -1,234 +0,0 @@
## Build instructions for Xcode 8.0
### Prepare folder
Choose a folder for the future build, for example **/Users/user/TBuild**
There you will have two folders, **Libraries** for third-party libs and **tdesktop** (or **tdesktop-master**) for the app.
**You will need this hierarchy to be able to follow this README !**
### Clone source code
By git – in Terminal go to **/Users/user/TBuild** and run:
git clone --recursive https://github.com/telegramdesktop/tdesktop.git
### Prepare libraries
In your build Terminal run:
MACOSX_DEPLOYMENT_TARGET=10.8
to set minimal supported OS version to 10.8 for future console builds.
#### zlib
In Terminal go to **/Users/user/TBuild/Libraries/zlib** and run:
git clone https://github.com/telegramdesktop/zlib.git
cd zlib
CFLAGS="-mmacosx-version-min=10.8" LDFLAGS="-mmacosx-version-min=10.8" ./configure
make
sudo make install
#### OpenSSL 1.0.1g
##### Get openssl-xcode project file
From https://github.com/telegramdesktop/openssl-xcode with git in Terminal:
* go to **/Users/user/TBuild/Libraries
* run:
git clone https://github.com/telegramdesktop/openssl-xcode.git
The path to openssl.xcodeproj should now be: **/Users/user/TBuild/Libraries/openssl-xcode/openssl.xcodeproj**
##### Get the source code:
Download [**openssl-1.0.1h.tar.gz**](http://www.openssl.org/source/openssl-1.0.1h.tar.gz) (4.3 Mb)
* Extract openssl-1.0.1h.tar.gz
* Copy everything from **openssl-1.0.1h** to **/Users/user/TBuild/Libraries/openssl-xcode**
The folder include of openssl should be:
**/Users/user/TBuild/Libraries/openssl-xcode/include**
##### Building library
* Open **/Users/user/TBuild/Libraries/openssl-xcode/openssl.xcodeproj** with Xcode
* Product > Build
#### liblzma
##### Get the source code
Download [**xz-5.0.5.tar.gz**](http://tukaani.org/xz/xz-5.0.5.tar.gz)
Extract to **/Users/user/TBuild/Libraries**
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/xz-5.0.5** and there run:
./configure
make
sudo make install
#### libexif 0.6.20
##### Get the source code
From https://github.com/telegramdesktop/libexif-0.6.20 with git in Terminal:
* go to **/Users/user/TBuild/Libraries**
* run:
git clone https://github.com/telegramdesktop/libexif-0.6.20.git
The folder configure should have this path:
**/Users/user/TBuild/Libraries/libexif-0.6.20/configure**
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/libexif-0.6.20** and there run
./configure
make
sudo make install
#### OpenAL Soft
Get sources by git – in Terminal go to **/Users/user/TBuild/Libraries** and run
git clone git://repo.or.cz/openal-soft.git
cd openal-soft/build
cmake -D LIBTYPE:STRING=STATIC -D CMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.8 ..
make
sudo make install
#### Opus codec
In Terminal go to **/Users/user/TBuild/Libraries** and there run
git clone https://github.com/xiph/opus
cd opus
git checkout v1.2-alpha2
./autogen.sh
CFLAGS="-mmacosx-version-min=10.8" CPPFLAGS="-mmacosx-version-min=10.8" LDFLAGS="-mmacosx-version-min=10.8" ./configure
make
sudo make install
#### FFmpeg and Libiconv
##### Get the source code
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone https://github.com/FFmpeg/FFmpeg.git ffmpeg
cd ffmpeg
git checkout release/3.2
* Download [libiconv-1.14](http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.14.tar.gz) from http://www.gnu.org/software/libiconv/#downloading
* Extract to **/Users/user/TBuild/Libraries** to have **/Users/user/TBuild/Libraries/ibiconv-1.14**
##### Building library
In Terminal go to **/Users/user/TBuild/Libraries/libiconv-1.14** and run:
CFLAGS="-mmacosx-version-min=10.8" CPPFLAGS="-mmacosx-version-min=10.8" LDFLAGS="-mmacosx-version-min=10.8" ./configure --enable-static
make
sudo make install
Then in Terminal go to **/Users/user/TBuild/Libraries/ffmpeg** and run:
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew install automake fdk-aac git lame libass libtool libvorbis libvpx opus sdl shtool texi2html theora wget x264 xvid yasm
CFLAGS=`freetype-config --cflags`
LDFLAGS=`freetype-config --libs`
PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig:/usr/lib/pkgconfig:/usr/X11/lib/pkgconfig
./configure --prefix=/usr/local --disable-programs --disable-doc --disable-everything --enable-protocol=file --enable-libopus --enable-decoder=aac --enable-decoder=aac_latm --enable-decoder=aasc --enable-decoder=flac --enable-decoder=gif --enable-decoder=h264 --enable-decoder=h264_vda --enable-decoder=mp1 --enable-decoder=mp1float --enable-decoder=mp2 --enable-decoder=mp2float --enable-decoder=mp3 --enable-decoder=mp3adu --enable-decoder=mp3adufloat --enable-decoder=mp3float --enable-decoder=mp3on4 --enable-decoder=mp3on4float --enable-decoder=mpeg4 --enable-decoder=msmpeg4v2 --enable-decoder=msmpeg4v3 --enable-decoder=opus --enable-decoder=pcm_alaw --enable-decoder=pcm_alaw_at --enable-decoder=pcm_f32be --enable-decoder=pcm_f32le --enable-decoder=pcm_f64be --enable-decoder=pcm_f64le --enable-decoder=pcm_lxf --enable-decoder=pcm_mulaw --enable-decoder=pcm_mulaw_at --enable-decoder=pcm_s16be --enable-decoder=pcm_s16be_planar --enable-decoder=pcm_s16le --enable-decoder=pcm_s16le_planar --enable-decoder=pcm_s24be --enable-decoder=pcm_s24daud --enable-decoder=pcm_s24le --enable-decoder=pcm_s24le_planar --enable-decoder=pcm_s32be --enable-decoder=pcm_s32le --enable-decoder=pcm_s32le_planar --enable-decoder=pcm_s64be --enable-decoder=pcm_s64le --enable-decoder=pcm_s8 --enable-decoder=pcm_s8_planar --enable-decoder=pcm_u16be --enable-decoder=pcm_u16le --enable-decoder=pcm_u24be --enable-decoder=pcm_u24le --enable-decoder=pcm_u32be --enable-decoder=pcm_u32le --enable-decoder=pcm_u8 --enable-decoder=pcm_zork --enable-decoder=vorbis --enable-decoder=wavpack --enable-decoder=wmalossless --enable-decoder=wmapro --enable-decoder=wmav1 --enable-decoder=wmav2 --enable-decoder=wmavoice --enable-encoder=libopus --enable-hwaccel=mpeg4_videotoolbox --enable-hwaccel=h264_vda --enable-hwaccel=h264_videotoolbox --enable-parser=aac --enable-parser=aac_latm --enable-parser=flac --enable-parser=h264 --enable-parser=mpeg4video --enable-parser=mpegaudio --enable-parser=opus --enable-parser=vorbis --enable-demuxer=aac --enable-demuxer=flac --enable-demuxer=gif --enable-demuxer=h264 --enable-demuxer=mov --enable-demuxer=mp3 --enable-demuxer=ogg --enable-demuxer=wav --enable-muxer=ogg --enable-muxer=opus --extra-cflags="-mmacosx-version-min=10.8" --extra-cxxflags="-mmacosx-version-min=10.8" --extra-ldflags="-mmacosx-version-min=10.8"
make
sudo make install
#### Qt 5.6.2, slightly patched
##### Get the source code
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone git://code.qt.io/qt/qt5.git qt5_6_2
cd qt5_6_2
perl init-repository --module-subset=qtbase,qtimageformats
git checkout v5.6.2
cd qtimageformats && git checkout v5.6.2 && cd ..
cd qtbase && git checkout v5.6.2 && cd ..
##### Apply the patch
From **/Users/user/TBuild/Libraries/qt5_6_2/qtbase**, run:
git apply ../../../tdesktop/Telegram/Patches/qtbase_5_6_2.diff
##### Building library
Go to **/Users/user/TBuild/Libraries/qt5_6_2** and run:
./configure -prefix "/usr/local/tdesktop/Qt-5.6.2" -debug-and-release -force-debug-info -opensource -confirm-license -static -opengl desktop -no-openssl -securetransport -nomake examples -nomake tests -platform macx-clang
make -j4
sudo make install
Building (**make** command) will take a really long time.
#### Google Crashpad
##### Install gyp
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone https://chromium.googlesource.com/external/gyp
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
cd gyp
git checkout 702ac58e47
git apply ../../tdesktop/Telegram/Patches/gyp.diff
./setup.py build
sudo ./setup.py install
cd ..
##### Build crashpad
In Terminal go to **/Users/user/TBuild/Libraries** and run:
git clone https://chromium.googlesource.com/crashpad/crashpad.git
cd crashpad
git checkout feb3aa3923
cd third_party/mini_chromium
git clone https://chromium.googlesource.com/chromium/mini_chromium
cd mini_chromium
git checkout 7c5b0c1ab4
git apply ../../../../../tdesktop/Telegram/Patches/mini_chromium.diff
cd ../../gtest
git clone https://chromium.googlesource.com/external/github.com/google/googletest gtest
cd gtest
git checkout d62d6c6556
cd ../../../
build/gyp_crashpad.py -Dmac_deployment_target=10.8
ninja -C out/Debug
ninja -C out/Release
#### Prepare GYP
In Terminal go to **/Users/user/TBuild/Libraries** and run
cd gyp
git apply ../../tdesktop/Telegram/Patches/gyp.diff
### Building Telegram Desktop
In Terminal go to **/home/user/TBuild/tdesktop/Telegram** and run
gyp/refresh.sh
Then launch Xcode, open **/Users/user/TBuild/tdesktop/Telegram/Telegram.xcodeproj** and build for Debug / Release.