Exemple #1
0
/**
 * @brief Saves Etk's config to disk
 * @return Returns ETK_TRUE on a successful save, ETK_FALSE otherwise.
 */
Etk_Bool etk_config_save(void)
{
   Eet_File *ef;
   char buf[PATH_MAX];
   char *home;
   Etk_Bool ret;

   home = getenv("HOME");
   if (!home)
     return 0;

   snprintf(buf, sizeof(buf), "%s/.e/etk/config.eet", home);

   ef = eet_open(buf, EET_FILE_MODE_WRITE);
   if (!ef)
     return 0;

   ret = eet_data_write(ef, _etk_config_ver_edd, "config/version",
			_etk_config->version, 1);
   if (!ret)
     ETK_WARNING("Problem saving config!");

   ret = eet_data_write(ef, _etk_config_gen_edd, "config/general",
			_etk_config->general, 1);
   if (!ret)
     ETK_WARNING("Problem saving config/stickies!");

   eet_close(ef);
   return ret;
}
Exemple #2
0
/**
 * @brief Initializes the config system
 * @return Returns true if initialization was successful, false otherwise
 */
Etk_Bool etk_config_init(void)
{
   char     *home;
   char      buf[PATH_MAX];

   home = getenv("HOME");
   if (!home)
   {
      ETK_WARNING("Cant find home directory!");
      return ETK_FALSE;
   }

   /* make sure ~/.e exists and is a dir */
   snprintf(buf, sizeof(buf), "%s/.e", home);
   if (!ecore_file_is_dir(buf))
   {
      if (ecore_file_exists(buf))
      {
	 ETK_WARNING("Cant create config path!");
	 return ETK_FALSE;
      }

      if (!ecore_file_mkdir(buf))
      {
	 ETK_WARNING("Cant create config path!");
	 return ETK_FALSE;
      }
   }

   /* make sure ~/.e/etk exists and is a dir */
   snprintf(buf, sizeof(buf), "%s/.e/etk", home);
   if (!ecore_file_is_dir(buf))
   {
      if (ecore_file_exists(buf))
      {
	 ETK_WARNING("Cant create config path!");
	 return ETK_FALSE;
      }

      if (!ecore_file_mkdir(buf))
      {
	 ETK_WARNING("Cant create config path!");
	 return ETK_FALSE;
      }
   }

   _etk_config_gen_edd = NEWD("Etk_Config_General", Etk_Config_General);
   CFG_GEN_NEWI("wmt", wm_theme, EET_T_STRING);
   CFG_GEN_NEWI("wt", widget_theme, EET_T_STRING);
   CFG_GEN_NEWI("fn", font, EET_T_STRING);
   CFG_GEN_NEWI("en", engine, EET_T_STRING);

   _etk_config_ver_edd = NEWD("Etk_Config_Version", Etk_Config_Version);
   CFG_VER_NEWI("mj", major, EET_T_INT);
   CFG_VER_NEWI("mn", minor, EET_T_INT);
   CFG_VER_NEWI("pa", patch, EET_T_INT);
   CFG_VER_NEWI("sp", subpatch, EET_T_INT);

   return ETK_TRUE;
}
EMessenger::EMessenger(eint64 targetTeam, euint64 targetToken, e_bigtime_t timestamp, e_status_t *perr)
	: fHandlerToken(E_MAXUINT64), fLooperToken(E_MAXUINT64),
	  fPort(NULL), fSem(NULL), fTargetTeam(E_INT64_CONSTANT(0))
{
	if(targetTeam != etk_get_current_team_id())
	{
		ETK_WARNING("[APP]: %s --- Remote target unsupported yet.", __PRETTY_FUNCTION__);
		if(perr) *perr = E_ERROR;
		return;
	}

	if(etk_ref_handler(targetToken) == false)
	{
		if(perr) *perr = E_ERROR;
		return;
	}

	euint64 looperToken = E_MAXUINT64;

	if(etk_get_handler_create_time_stamp(targetToken) != timestamp ||
	   (looperToken = etk_get_ref_looper_token(targetToken)) == E_MAXUINT64)
	{
		etk_unref_handler(targetToken);
		if(perr) *perr = E_ERROR;
		return;
	}

	fTargetTeam = targetTeam;
	fHandlerToken = targetToken;
	fLooperToken = looperToken;

	if(perr) *perr = E_OK;
}
e_font_detach_callback*
EFontFT2::Attach(void (*callback)(void*), void *data)
{
	EAutolock <ELocker> autolock(&etk_ft2_font_locker);

	e_font_detach_callback *eCallback = EFontEngine::Attach(callback, data);

	if(eCallback && !fFace)
	{
		if(FT_New_Face(_etk_ft2_library_, fFilename, fFaceIndex, &fFace) || !fFace)
		{
			ETK_DEBUG("[FONT]: %s --- CAN NOT load face[%s:%d].", __PRETTY_FUNCTION__, fFilename, fFaceIndex);
			EFontEngine::Detach(eCallback);
			return NULL;
		}

		if(FT_Select_Charmap(fFace, FT_ENCODING_UNICODE))
		{
			if(FT_Select_Charmap(fFace, FT_ENCODING_NONE))
			{
				ETK_WARNING("[FONT]: %s --- font[%s] don't support unicode at all.", __PRETTY_FUNCTION__, fFilename);
				FT_Done_Face(fFace);
				fFace = NULL;
				EFontEngine::Detach(eCallback);
				return NULL;
			}
		}
	}

	return eCallback;
}
Exemple #5
0
status_t
BScrollBar::SetTarget(BView *target)
{
	if (target == this) return B_ERROR;
	if (target == fTarget) return B_OK;

	if (target != NULL) {
		if (!(target->Ancestor() == Ancestor() || (target->Window() == Window() && Window() != NULL))) {
			ETK_WARNING("[INTERFACE]: %s --- target hasn't same ancestor as this.", __PRETTY_FUNCTION__);
			return B_BAD_VALUE;
		}
		if (target->fScrollBar.AddItem(this) == false) return B_ERROR;
	}

	if (fTarget != NULL) fTarget->fScrollBar.RemoveItem(this);
	fTarget = target;

	if (fTarget != NULL) {
		if (fOrientation == B_HORIZONTAL)
			fTarget->ScrollTo(fValue, fTarget->LeftTop().y);
		else
			fTarget->ScrollTo(fTarget->LeftTop().x, fValue);
	}

	return B_OK;
}
static void server()
{
	ENetEndpoint endpoint(SOCK_STREAM);

	if(endpoint.InitCheck() != E_OK) ETK_ERROR("Failed to create endpoint: %s.", endpoint.ErrorStr());
	if(endpoint.Bind(DEFAULT_PORT) != E_OK) ETK_ERROR("Bind(%d) failed: %s.", DEFAULT_PORT, endpoint.ErrorStr());
	if(endpoint.Listen() != E_OK) ETK_ERROR("Listen() failed: %s.", endpoint.ErrorStr());

	while(true)
	{
		ETK_OUTPUT("Waiting for client ...\n");

		ENetEndpoint *connection = endpoint.Accept(500);
		if(connection == NULL)
		{
			ETK_WARNING("Accept() == NULL: %s.", endpoint.ErrorStr());
			continue;
		}

		struct in_addr addr;
		euint16 port;
		connection->RemoteAddr().GetAddr(addr, &port);

		euint32 ip = E_BENDIAN_TO_HOST_INT32(addr.s_addr);
		ETK_OUTPUT("connection from %d.%d.%d.%d, port: %d\n",
			   ip >> 24, (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff, port);

		EString buf;
		time_t curTime = time(NULL);
		buf << ctime(&curTime) << "\r\n";
		connection->Send(buf.String(), buf.Length());

		delete connection;
	}
}
EMessenger::EMessenger(const char *signature, eint64 team, e_status_t *perr)
	: fHandlerToken(E_MAXUINT64), fLooperToken(E_MAXUINT64),
	  fPort(NULL), fSem(NULL), fTargetTeam(E_INT64_CONSTANT(0))
{
	// TODO
	ETK_WARNING("[APP]: %s --- Remote target unsupported yet.", __PRETTY_FUNCTION__);
	if(perr) *perr = E_ERROR;
}
EWin32GraphicsWindow::EWin32GraphicsWindow(EWin32GraphicsEngine *win32Engine, eint32 x, eint32 y, euint32 w, euint32 h)
	: EGraphicsWindow(), win32Window(NULL),
	  fLook((e_window_look)0), fFeel((e_window_feel)0), fActivateWhenShown(false), hbrBackground(NULL),
	  fEngine(NULL), fRequestWin(NULL), fRequestAsyncWin(NULL), WM_ETK_MESSAGE(0)
{
	if(w == E_MAXUINT32 || h == E_MAXUINT32)
	{
		ETK_DEBUG("[GRAPHICS]: %s --- Either width or height is so large.", __PRETTY_FUNCTION__);
		return;
	}

	if(win32Engine == NULL) return;

	do {
		EAutolock <EWin32GraphicsEngine> autolock(win32Engine);
		if(autolock.IsLocked() == false || win32Engine->InitCheck() != E_OK ||
		   win32Engine->WM_ETK_MESSAGE == 0 ||
		   win32Engine->win32RequestWin == NULL || win32Engine->win32RequestAsyncWin == NULL)
		{
			if(fRequestWin != NULL) CloseHandle(fRequestWin);
			if(fRequestAsyncWin != NULL) CloseHandle(fRequestAsyncWin);
			ETK_WARNING("[GRAPHICS]: %s --- Invalid engine or unable to duplicate handle.", __PRETTY_FUNCTION__);
			return;
		}

		WM_ETK_MESSAGE = win32Engine->WM_ETK_MESSAGE;
		fRequestWin = win32Engine->win32RequestWin;
		fRequestAsyncWin = win32Engine->win32RequestAsyncWin;
	} while(false);

	e_rgb_color whiteColor = {255, 255, 255, 255};
	EGraphicsDrawable::SetBackgroundColor(whiteColor);

	etk_win32_gdi_callback_t callback;
	callback.command = WM_ETK_MESSAGE_CREATE_WINDOW;
	callback.win = this;
	callback.x = x;
	callback.y = y;
	callback.w = w;
	callback.h = h;
	callback.bkColor = whiteColor;

	bool successed = (SendMessageA(fRequestWin, WM_ETK_MESSAGE,
				       WM_ETK_MESSAGE_WINDOW, (LPARAM)&callback) == (LRESULT)TRUE);

	if(successed == false || win32Window == NULL)
	{
		ETK_DEBUG("[GRAPHICS]: %s --- Unable to create window: \"%s\".",
			  __PRETTY_FUNCTION__, successed ? "win32Window = NULL" : "SendMessageA failed");
	}
	else
	{
		fEngine = win32Engine;
	}
}
void
EMessageQueue::Unlock()
{
	if(etk_count_locker_locks(fLocker) <= 0)
	{
		ETK_WARNING("[APP]: %s -- MessageQueue wasn't locked by current thread.", __PRETTY_FUNCTION__);
		return;
	}

	etk_unlock_locker(fLocker);
}
e_status_t
EMessenger::_SendMessageToPort(void *port, const EMessage *msg, euint32 flags, e_bigtime_t timeout)
{
	if(!port || !msg) return E_ERROR;

	size_t flattenedSize = msg->FlattenedSize();
	if(flattenedSize <= 0)
	{
		ETK_WARNING("[APP]: Faltten size little than 1. (%s:%d)", __FILE__, __LINE__);
		return E_ERROR;
	}

	char *buffer = (char*)malloc(flattenedSize);
	if(!buffer)
	{
		ETK_WARNING("[APP]: Buffer malloc failed. (%s:%d)", __FILE__, __LINE__);
		return E_NO_MEMORY;
	}

	if(msg->Flatten(buffer, flattenedSize) == false)
	{
		free(buffer);
		ETK_WARNING("[APP]: Flatten message failed. (%s:%d)", __FILE__, __LINE__);
		return E_ERROR;
	}

	e_status_t status;
	if((status = etk_write_port_etc(port, _EVENTS_PENDING_, buffer, flattenedSize, flags, timeout)) != E_OK)
	{
		free(buffer);
		ETK_WARNING("[APP]: write port %s. (%s:%d)", status == E_TIMEOUT ? "time out" : "failed", __FILE__, __LINE__);
		return status;
	}

	free(buffer);

	return E_OK;
}
_IMPEXP_ETK bool etk_font_freetype2_init(void)
{
	EAutolock <ELocker> autolock(&etk_ft2_font_locker);

	if(!_etk_ft2_initialized_)
	{
		FT_Error error = FT_Init_FreeType(&_etk_ft2_library_);
		if(error)
		{
			ETK_WARNING("[FONT]: %s --- CAN NOT initialize freetype engine %d\n", __PRETTY_FUNCTION__, error);
			return false;
		}
		_etk_ft2_initialized_ = true;
	}

	return true;
}
e_status_t
EMessenger::SendMessage(const EMessage *a_message, EMessage *reply_message, e_bigtime_t sendTimeout, e_bigtime_t replyTimeout) const
{
	if(a_message == NULL || reply_message == NULL)
	{
		ETK_WARNING("[APP]: %s --- Can't post empty message or \"reply_message\" assigned to be \"NULL\".", __PRETTY_FUNCTION__);
		return E_BAD_VALUE;
	}

	void *port = etk_create_port(1, NULL, ETK_AREA_ACCESS_OWNER);
	if(port == NULL) return E_NO_MORE_PORTS;

	EMessage *aMsg = new EMessage(*a_message);
	if(aMsg->fSource != NULL) etk_delete_port(aMsg->fSource);
	aMsg->fTeam = etk_get_current_team_id();
	aMsg->fIsReply = false;
	aMsg->fReplyToken = E_MAXUINT64;
	aMsg->fReplyTokenTimestamp = E_MAXINT64;
	aMsg->fNoticeSource = true; // auto close the port when deleted
	aMsg->fSource = port; // auto delete the port when deleted

	e_status_t status = _SendMessage(aMsg, E_MAXUINT64, sendTimeout);
	if(status == E_OK)
	{
		EMessage *reply = _GetMessageFromPort(port, E_TIMEOUT, replyTimeout, &status);
		if(reply != NULL)
		{
			*reply_message = *reply;
			delete reply;
		}
		else
		{
			reply_message->what = E_NO_REPLY;
		}
	}

	delete aMsg;
	return status;
}
_IMPEXP_ETK e_status_t etk_unlock_locker(void *data)
{
	etk_posix_locker_t *locker = (etk_posix_locker_t*)data;
	if(!locker) return E_BAD_VALUE;

	etk_lock_locker_inter(locker);

	if(locker->HolderThreadIsCurrent() == false)
	{
		etk_unlock_locker_inter(locker);
		ETK_WARNING("[KERNEL]: %s -- Can't unlock when didn't hold it in current thread!", __PRETTY_FUNCTION__);
		return E_ERROR;
	}
	else
	{
		if(locker->lockCount <= E_INT64_CONSTANT(1))
		{
			if(pthread_mutex_unlock(&(locker->Locker)) != 0)
			{
				etk_unlock_locker_inter(locker);
				return E_ERROR;
			}
		}

		locker->lockCount--;

		if(locker->lockCount <= E_INT64_CONSTANT(0))
		{
			locker->SetHolderThreadId(E_INT64_CONSTANT(0));
			locker->lockCount = E_INT64_CONSTANT(0);
			pthread_cond_broadcast(&(locker->Cond));
		}

		etk_unlock_locker_inter(locker);
	}

	return E_OK;
}
e_status_t
EMessenger::SendMessage(const EMessage *a_message,
			EHandler *reply_to,
			e_bigtime_t timeout) const
{
	if(a_message == NULL)
	{
		ETK_WARNING("[APP]: %s --- Can't post empty message.", __PRETTY_FUNCTION__);
		return E_BAD_VALUE;
	}

	euint64 replyToken = etk_get_handler_token(reply_to);

	EMessage aMsg(*a_message);
	aMsg.fIsReply = false;
	if(aMsg.fSource != NULL)
	{
		etk_delete_port(aMsg.fSource);
		aMsg.fSource = NULL;
	}

	return _SendMessage(&aMsg, replyToken, timeout);
}
e_status_t
EDFBGraphicsEngine::UpdateFonts(bool check_only)
{
	EString fonts_dirs;

	const char *dirs = getenv("DIRECTFB_FONTS_DIR");
	if(dirs) fonts_dirs += dirs;

	if(fonts_dirs.Length() <= 0)
		ETK_WARNING("[FONT]: you can set the environment \"DIRECTFB_FONTS_DIR\" to match the correct dirs.");

	EAutolock <EDFBGraphicsEngine> autolock(this);
	if(autolock.IsLocked() == false || InitCheck() != E_OK) return E_ERROR;

	if(check_only)
	{
		ETK_WARNING("[GRAPHICS]: %s --- check_only not implement yet.", __PRETTY_FUNCTION__);
		return E_ERROR;
	}

	ETK_DEBUG("[GRAPHICS]: Updating DirectFB fonts ...");

	EStringArray *fonts_dirs_array = fonts_dirs.Split(":");
	ETK_DEBUG("[FONT]: Fonts directory number: %d", (fonts_dirs_array ? fonts_dirs_array->CountItems() : 0));

	eint32 count = 0;
	const EString *_fonts_dir;
	for(eint32 m = 0; (_fonts_dir = (fonts_dirs_array ? fonts_dirs_array->ItemAt(m) : NULL)) != NULL; m++)
	{
		EDirectory directory(_fonts_dir->String());
		if(directory.InitCheck() != E_OK)
		{
			ETK_WARNING("[FONT]: CAN NOT open fonts directory - \"%s\"!", _fonts_dir->String());
			continue;
		}
		ETK_DEBUG("[FONT]: Opening font directory \"%s\"...", _fonts_dir->String());

		EEntry aEntry;
		while(directory.GetNextEntry(&aEntry, true) == E_OK)
		{
			EPath aPath;
			if(aEntry.GetPath(&aPath) != E_OK) continue;
			EString filename = aPath.Leaf();

			if(filename.Length() <= 0 || filename == "." || filename == "..") continue;

			ETK_DEBUG("[FONT]: Reading font file \"%s\" ...", aPath.Path());

			EDFBFont *engine = new EDFBFont(this, aPath.Path());
			if(engine == NULL || engine->IsValid() == false ||
			   etk_font_add(engine->Family(), engine->Style(), engine) == false)
			{
				if(engine) delete engine;
				continue;
			}

			count++;
		}
	}
	if(fonts_dirs_array) delete fonts_dirs_array;

	if(count == 0)
	{
		EDFBFont *engine = new EDFBFont(this, NULL);
		if(engine == NULL || engine->IsValid() == false ||
		   etk_font_add(engine->Family(), engine->Style(), engine) == false)
		{
			if(engine) delete engine;
		}
	}

	ETK_DEBUG("[GRAPHICS]: DirectFB fonts updated.");

	return E_OK;
}
_IMPEXP_ETK bool etk_update_freetype2_font_families(bool check_only)
{
	EString fonts_dirs;

#ifdef _WIN32
	const char dir_env_sep = ';';
#else
	const char dir_env_sep = ':';
#endif

	const char *dirs = getenv("FREETYPE_FONTS_DIR");
	if(dirs) fonts_dirs += dirs;

	if(fonts_dirs.Length() <= 0)
	{
#ifdef _WIN32
		fonts_dirs = "C:\\Progra~1\\freetype";
#elif defined(ETK_OS_BEOS)
		fonts_dirs = "/boot/beos/etc/fonts/ttfonts";
		ETK_WARNING("[FONT]: you can set the environment \"FREETYPE_FONTS_DIR\" to match the correct dirs.");
#else
		fonts_dirs = "/usr/share/fonts/freetype";
#endif
	}

	EAutolock <ELocker> autolock(&etk_ft2_font_locker);

	if(check_only)
	{
		ETK_WARNING("[FONT]: %s --- check_only not implement yet.", __PRETTY_FUNCTION__);
		return false;
	}

	if(!_etk_ft2_initialized_)
	{
		ETK_WARNING("[FONT]: Freetype engine not initialize! REFUSE TO LOAD FONTS!!!");
		return false;
	}

	EStringArray *fonts_dirs_array = fonts_dirs.Split(dir_env_sep);
	if(!fonts_dirs_array)
	{
		ETK_WARNING("[FONT]: %s --- Couldn't find any font directory.", __PRETTY_FUNCTION__);
		return false;
	}

	ETK_DEBUG("[FONT]: Updating FreeType2 fonts ...");
//	ETK_DEBUG("[FONT]: Fonts directory number: %d", fonts_dirs_array->CountItems());

	const EString *_fonts_dir;
	for(eint32 m = 0; (_fonts_dir = fonts_dirs_array->ItemAt(m)) != NULL; m++)
	{
		EDirectory directory(_fonts_dir->String());
		if(directory.InitCheck() != E_OK)
		{
			ETK_WARNING("[FONT]: CAN NOT open fonts directory - \"%s\"!", _fonts_dir->String());
			continue;
		}
//		ETK_DEBUG("[FONT]: Opening font directory \"%s\"...", _fonts_dir->String());

		EEntry aEntry;
		while(directory.GetNextEntry(&aEntry, true) == E_OK)
		{
			EPath aPath;
			if(aEntry.GetPath(&aPath) != E_OK) continue;
			EString filename = aPath.Leaf();

			// Ignore not "*.ttf" etc...
			if(filename.Length() < 5) continue;
			const char *fontPattern[] = {".ttf", ".ttc", ".pcf", ".fon", ".pfa", ".pfb"};
			bool isPatternMatched = false;
			for(euint8 i = 0; i < 6; i++)
			{
				if(filename.IFindLast(fontPattern[i]) == filename.Length() - (eint32)strlen(fontPattern[i]))
				{
					isPatternMatched = true;
					break;
				}
			}
			if(!isPatternMatched) continue;

//			ETK_DEBUG("[FONT]: Reading font file \"%s\" ...", aPath.Path());

			eint32 faceIndex = 0, nFaces = 0;
			do{
				EFontFT2 *engine = new EFontFT2(&aEntry, faceIndex);
				if(!engine || !engine->IsValid())
				{
					if(engine) delete engine;

					if(faceIndex == 0)
						break;
					else
					{
						faceIndex++;
						continue;
					}
				}

				if(faceIndex == 0)
				{
					nFaces = engine->CountFaces();
//					ETK_DEBUG("\tFaces Number: %d", nFaces);
				}

//				ETK_DEBUG("\tFamily[%d]: %s", faceIndex, engine->Family());
//				ETK_DEBUG("\t\tStyle: %s", engine->Style());

				if(!etk_font_add(engine->Family(), engine->Style(), engine)) delete engine;

				faceIndex++;
			}while(faceIndex < nFaces);
		}
	}

	if(fonts_dirs_array) delete fonts_dirs_array;

	ETK_DEBUG("[FONT]: FreeType2 fonts updated.");

	return true;
}
Exemple #17
0
/**
 * @brief Loads Etk's config from disk
 * @return Returns ETK_TRUE on a successful load, ETK_FALSE otherwise.
 */
Etk_Bool etk_config_load(void)
{
   Eet_File *ef;
   char buf[PATH_MAX];
   char *home;

   home = getenv("HOME");
   if (!home)
     {
	_etk_config_defaults_apply();
	return ETK_FALSE;
     }

   snprintf(buf, sizeof(buf), "%s/.e/etk/config.eet", home);

   if (!ecore_file_exists(buf) || ecore_file_size(buf) == 0)
   {
      /* no saved config */
      _etk_config_defaults_apply();
      return ETK_FALSE;
   }

   ef = eet_open(buf, EET_FILE_MODE_READ);
   if (!ef)
   {
      ETK_WARNING("Cant open configuration file! Using program defaults.");
      return ETK_FALSE;
   }

   if (!_etk_config)
     _etk_config = malloc(sizeof(Etk_Config));
   else
   {
      free(_etk_config->version);
      if (_etk_config->general)
      {
	 free(_etk_config->general->wm_theme);
	 free(_etk_config->general->widget_theme);
	 free(_etk_config->general->font);
	 free(_etk_config->general->engine);
	 free(_etk_config->general);
      }
   }

   _etk_config->version = NULL;
   _etk_config->version = eet_data_read(ef, _etk_config_ver_edd, "config/version");
   if(!_etk_config->version)
     {
	ETK_WARNING("Incompatible configuration file! Creating new one.");
	eet_close(ef);
	_etk_config_defaults_apply();
	return ETK_FALSE;
     }
   else
     {
	Etk_Config_Version *v;

	v = _etk_config_version_parse(VERSION);
	if(_etk_config_version_compare(v, _etk_config->version) != 0)
	  {
	     ETK_WARNING("Your version / configuration of Etk is not valid!");
	     eet_close(ef);
	     free(v);
	     _etk_config_defaults_apply();
	     return ETK_FALSE;
	  }
	free(v);
     }

   _etk_config->general = eet_data_read(ef, _etk_config_gen_edd, "config/general");
   if (!_etk_config->general)
     _etk_config_defaults_apply();

   eet_close(ef);
   return ETK_TRUE;
}
_IMPEXP_ETK void*
etk_clone_area(const char *name, void **dest_addr, euint32 protection, const char *domain)
{
	char *ipc_name = etk_area_ipc_name(name, domain);
	if(!ipc_name) return NULL;

	etk_win32_area_t *area = new etk_win32_area_t();
	if(!area)
	{
		free(ipc_name);
		return NULL;
	}

	area->prot = protection;

	DWORD prot = (protection & E_WRITE_AREA ? FILE_MAP_ALL_ACCESS : FILE_MAP_READ);

	HANDLE handler;

	_ETK_LOCK_AREA_();
	if((handler = OpenFileMapping(prot, FALSE, ipc_name)) == NULL)
	{
//		ETK_DEBUG("[KERNEL]: %s --- Can't clone area : open file mapping failed."", __PRETTY_FUNCTION__);
		_ETK_UNLOCK_AREA_();
		free(ipc_name);
		delete area;
		return NULL;
	}

	if((area->addr = MapViewOfFile(handler, prot, 0, 0, 0)) == NULL)
	{
		ETK_DEBUG("[KERNEL]: %s --- Can't clone area : MapViewOfFile failed.", __PRETTY_FUNCTION__);
		CloseHandle(handler);
		_ETK_UNLOCK_AREA_();
		free(ipc_name);
		delete area;
		return NULL;
	}

	etk_win32_area_info_t area_info;
	bzero(&area_info, sizeof(etk_win32_area_info_t));
	memcpy(&area_info, area->addr, sizeof(etk_win32_area_info_t));
	if(area_info.magic != WIN32_AREA_INFO_MAGIC || area_info.closed)
	{
		ETK_WARNING("[KERNEL]: %s --- FileMapping(%s) seem not created by ETK", __PRETTY_FUNCTION__, ipc_name);
		UnmapViewOfFile(area->addr);
		CloseHandle(handler);
		_ETK_UNLOCK_AREA_();
		free(ipc_name);
		delete area;
		return NULL;
	}

	area->length = area_info.length;
	area->mapping = handler;
	area->name = e_strdup(name);
	area->domain = e_strdup(domain);
	area->ipc_name = ipc_name;
	area->openedIPC = true;
	area->created = true;

	_ETK_UNLOCK_AREA_();

	if(dest_addr) *dest_addr = (void*)((char*)area->addr + sizeof(etk_win32_area_info_t));
	return area;
}
euint8*
EFontFT2::RenderString(const char *string, eint32 *width, eint32 *height, bool *is_mono,
		       float size, float spacing, float shear, bool bold, eint32 length)
{
	if(string == NULL || *string == 0 || length == 0 || width == NULL || height == NULL || is_mono == NULL) return NULL;

	EAutolock <ELocker> autolock(&etk_ft2_font_locker);

	if(!IsAttached()) return NULL;

	bool isfixed = IsFixedSize(size);
	if(!fScalable && !isfixed) return NULL;

	float stringWidth;
	e_font_height fontHeight;

	if((stringWidth = StringWidth(string, size, spacing, shear, bold, length)) <= 0) return NULL;
	GetHeight(&fontHeight, size, shear, bold);

	eint32 w, h;
	w = (eint32)ceil(stringWidth) + 1;
	h = (eint32)ceil(fontHeight.ascent + fontHeight.descent) + 1;

	euint8 *bitmap = new euint8[w * h];
	if(!bitmap)
	{
		ETK_WARNING("[FONT]: %s --- Unable to alloc memory for bitmap data.", __PRETTY_FUNCTION__);
		return NULL;
	}
	bzero(bitmap, sizeof(euint8) * (size_t)(w * h));

	eunichar *unicode = e_utf8_convert_to_unicode(string, length);
	if(!unicode)
	{
		delete[] bitmap;
		return NULL;
	}

	const eunichar *ch;
	euint32 x = 0;
	euint32 y = (euint32)ceil(fontHeight.ascent);
	bool do_mono = fForceFontAliasing;
	for(ch = unicode; !(ch == NULL || *ch == 0); ch = e_unicode_next(ch, NULL))
	{
		if(FT_Load_Char(fFace, *ch, (do_mono ? (FT_LOAD_RENDER | FT_LOAD_MONOCHROME) : FT_LOAD_RENDER)))
		{
			ETK_DEBUG("[FONT]: %s --- FT_Load_Char failed.", __PRETTY_FUNCTION__);
			continue;
		}

		FT_Bitmap *ftbitmap = &(fFace->glyph->bitmap);

		eint32 xx = x + (eint32)(fFace->glyph->bitmap_left);
		eint32 yy = y - (eint32)(fFace->glyph->bitmap_top);
		eint32 bitmapWidth = (eint32)(ftbitmap->width);
		eint32 bitmapHeight = (eint32)(ftbitmap->rows);
		eint32 lineBytes = (eint32)(ftbitmap->pitch > 0 ? ftbitmap->pitch : -(ftbitmap->pitch));
		eint32 maxxx = min_c(w, xx + bitmapWidth);
		eint32 maxyy = min_c(h, yy + bitmapHeight);

		for(eint32 i = yy, p = 0; i < maxyy; i++, p++)
		{
			euint8* dest = bitmap;
			dest += i * w + xx;
			unsigned char* src = ftbitmap->buffer;
			src += p * lineBytes;

			switch(ftbitmap->pixel_mode)
			{
				case FT_PIXEL_MODE_GRAY:
					for(eint32 j = xx; j < maxxx; j++) *dest++ = (euint8)(*src++);
					break;

				case FT_PIXEL_MODE_MONO:
					for(eint32 j = xx; j < maxxx; )
					{
						euint8 val = (euint8)(*src++);
						eint32 left = maxxx - j >= 8 ? 8 : maxxx - j;
						euint8 left_offset = 7;

						for(eint32 k = 0; k < left; k++, left_offset--, j++)
							*dest++ = (val & (1 << left_offset)) ? 255 : 0;
					}
					break;

				default:
					ETK_DEBUG("[FONT]: %s --- The mode of freetype bitmap not supported.", __PRETTY_FUNCTION__);
			}
		}

		x += (euint32)((float)(fFace->glyph->metrics.horiAdvance) / 64.f) + (euint32)ceil((double)(spacing * size)); // next x
	}

	free(unicode);

	*width = w;
	*height = h;
	*is_mono = do_mono;

	return bitmap;
}
_IMPEXP_ETK e_status_t
etk_resize_area(void *data, void **start_addr, size_t new_size)
{
	ETK_WARNING("%s: Not supported.", __PRETTY_FUNCTION__);
	return E_ERROR;
}
_IMPEXP_ETK e_status_t
etk_set_area_protection(void *data, euint32 new_protection)
{
	ETK_WARNING("%s: Not supported.", __PRETTY_FUNCTION__);
	return E_ERROR;
}
EMessage*
EMessenger::_GetMessageFromPort(void *port, euint32 flags, e_bigtime_t timeout, e_status_t *err)
{
	e_status_t retErr = E_OK;
	EMessage* retMsg = NULL;

	do{
		ssize_t bufferSize = etk_port_buffer_size_etc(port, flags, timeout);
		if(bufferSize == 0)
		{
			eint32 code;
			retErr = etk_read_port_etc(port, &code, NULL, 0, E_TIMEOUT, E_INT64_CONSTANT(0));
//			if(retErr != E_OK) ETK_DEBUG("[APP]: Port read failed(0x%x). (%s:%d)", retErr, __FILE__, __LINE__);
			break;
		}
		else if(bufferSize < 0)
		{
			retErr = bufferSize;
//			if(!(retErr == E_WOULD_BLOCK || retErr == E_TIMED_OUT))
//				ETK_DEBUG("[APP]: Port read failed(0x%x). (%s:%d)", retErr, __FILE__, __LINE__);
			break;
		}

		char *buffer = (char*)malloc((size_t)bufferSize);
		if(!buffer)
		{
			retErr = E_NO_MEMORY;
			ETK_WARNING("[APP]: Memory alloc failed. (%s:%d)", __FILE__, __LINE__);
			break;
		}
		bzero(buffer, (size_t)bufferSize);

		eint32 code;
		if((retErr = etk_read_port_etc(port, &code, buffer, bufferSize, E_TIMEOUT, E_INT64_CONSTANT(0))) != E_OK)
		{
//			ETK_DEBUG("[APP]: Port read failed(0x%x). (%s:%d)", retErr, __FILE__, __LINE__);
			free(buffer);
			break;
		}
		if(code != _EVENTS_PENDING_ || (size_t)bufferSize < sizeof(size_t))
		{
			ETK_WARNING("[APP]: Message is invalid. (%s:%d)", __FILE__, __LINE__);
			free(buffer);
			retErr = E_ERROR;
			break;
		}

		size_t msgBufferSize = 0;
		memcpy(&msgBufferSize, buffer, sizeof(size_t));
		if(bufferSize != (ssize_t)msgBufferSize) /* the first "size_t" == FlattenedSize() */
		{
			ETK_WARNING("[APP]: Message length is invalid. (%s:%d)", __FILE__, __LINE__);
			free(buffer);
			retErr = E_ERROR;
			break;
		}

		if((retMsg = new EMessage()) == NULL)
		{
			ETK_WARNING("[APP]: Memory alloc failed. (%s:%d)", __FILE__, __LINE__);
			free(buffer);
			retErr = E_NO_MEMORY;
			break;
		}

		if(retMsg->Unflatten(buffer, msgBufferSize) == false)
		{
			ETK_WARNING("[APP]: Message unflatten failed. (%s:%d)", __FILE__, __LINE__);
			delete retMsg;
			retMsg = NULL;
			retErr = E_ERROR;
		}

		free(buffer);
	}while(false);

	if(err) *err = retErr;
	return retMsg;
}
Exemple #23
0
/**
 * @brief Does the same thing as etk_init() except you can specify custom arguments that could be then retrieved with
 * etk_argument_* functions. For example, etk_init_full(argc, argv, "--option1 value --toggle1")
 * @param argc the location of the "argc" parameter passed to main(). It is used to parse the arguments specific to Etk.
 * It can be set to NULL.
 * @param argv the location of the "argv" parameter passed to main(). It is used to parse the arguments specific to Etk.
 * It can be set to NULL.
 * @param custom_opts a string corresponding to the custom arguments to add to argv. It can be set to NULL
 * @return Returns the number of times Etk has been initialized, or 0 on failure
 * @note It initializes Evas, Ecore and Edje so you don't need to initialize them after an etk_init()
 * @see etk_init()
 * @see etk_shutdown()
 */
int etk_init_full(int argc, char **argv, const char *custom_opts)
{
   char *engine_name = NULL;

   if (_etk_main_init_count > 0)
   {
      _etk_main_init_count++;
      return _etk_main_init_count;
   }
   else
   {
      /* Parse the arguments */
      etk_argument_init(argc, argv, custom_opts);
      etk_argument_value_get("etk-engine", 0, ETK_TRUE, &engine_name);

      /* Initialize the EFL */
      if (!evas_init())
      {
         ETK_WARNING("Evas initialization failed!");
         return 0;
      }
      if (!ecore_init())
      {
         ETK_WARNING("Ecore initialization failed!");
         return 0;
      }
      if (!ecore_imf_init())
      {
         ETK_WARNING("Ecore_IMF initialization failed!");
      }
      if (!edje_init())
      {
         ETK_WARNING("Edje initialization failed!");
         return 0;
      }

      /* TODO: maybe we should do this in etk_main().
       * Problem: if we do this, a program that uses directly ecore_main_loop_begin() and not etk_main() won't work */
      _etk_main_idle_enterer = ecore_idle_enterer_add(_etk_main_idle_enterer_cb, NULL);

      /* Initialize the subsystems of Etk */
      if (!etk_config_init())
      {
         ETK_WARNING("Etk_Config initialization failed!");
         return 0;
      }
      etk_config_load();
      etk_theme_init();
      if (!etk_engine_init())
      {
         ETK_WARNING("Etk_Engine initialization failed!");
         return 0;
      }
      if (!etk_engine_load(engine_name ? engine_name : "ecore_evas_software_x11"))
      {
         ETK_WARNING("Etk can not load the requested engine!");
         return 0;
      }
      etk_event_init();
      etk_tooltips_init();

      /* Initialize Gettext */
      setlocale(LC_ALL, "");
      bindtextdomain(PACKAGE, LOCALEDIR);
      textdomain(PACKAGE);

      free(engine_name);
      _etk_main_init_count++;
      return _etk_main_init_count;
   }
}
Exemple #24
0
/* Adds a new widget to the box, after the cell "after" */
static void _etk_box_insert_after_cell(Etk_Box *box, Etk_Widget *child, Etk_Box_Group group, Etk_Box_Cell *after, Etk_Box_Fill_Policy fill_policy, int padding)
{
   Etk_Box_Cell *cell;
   Etk_Widget *box_widget;

   if (!(box_widget = ETK_WIDGET(box)) || !child)
      return;
   if (after && after->group != group)
   {
      ETK_WARNING("The child to pack and the widget after which the child should be packed "
         "do not belong to the same child-group");
      return;
   }

   cell = malloc(sizeof(Etk_Box_Cell));
   cell->prev = NULL;
   cell->next = NULL;
   cell->child = child;
   cell->focus_node = NULL;
   cell->group = group;
   cell->fill_policy = fill_policy;
   cell->padding = padding;

   if (after)
   {
      cell->prev = after;
      cell->next = after->next;
      if (after->next)
         after->next->prev = cell;
      else
         box->last_cell[group] = cell;
      after->next = cell;

      box_widget->focus_order = eina_list_append_relative_list(box_widget->focus_order, child, after->focus_node);
      cell->focus_node = eina_list_next(after->focus_node);
   }
   else
   {
      cell->next = box->first_cell[group];
      if (box->first_cell[group])
         box->first_cell[group]->prev = cell;
      else
         box->last_cell[group] = cell;
      box->first_cell[group] = cell;

      if (group == ETK_BOX_START || !box->last_cell[ETK_BOX_START])
      {
         box_widget->focus_order = eina_list_prepend(box_widget->focus_order, child);
         cell->focus_node = box_widget->focus_order;
      }
      else
      {
         box_widget->focus_order = eina_list_append_relative_list(box_widget->focus_order,
               child, box->last_cell[ETK_BOX_START]->focus_node);
         cell->focus_node = eina_list_next(box->last_cell[ETK_BOX_START]->focus_node);
      }
   }
   box->cells_count[group]++;

   etk_widget_parent_set(child, ETK_WIDGET(box));
   etk_object_data_set(ETK_OBJECT(child), "_Etk_Box::Cell", cell);
   etk_signal_emit(ETK_CONTAINER_CHILD_ADDED_SIGNAL, ETK_OBJECT(box), child);
}