/*
* USB interfaces may optionally have a string discriptor assoicated with them.
* This returns that descriptor
*/
VALUE interface_interface_string(VALUE self)
{
struct usb_interface_descriptor* interface;
Data_Get_Struct(self, struct usb_interface_descriptor, interface);
return get_string_index(rb_iv_get(self, "@device"), interface->iInterface);
}
// recursive parsing of menu file
static Menu* ParseMenu(struct menu_src *src, const char *title, const char *IDString)
{
char line[4000];
char data[4000];
char buffer[4000];
char command[40];
char label[MAX_PATH];
Menu *pMenu, *pSub;
MenuItem *pItem;
int f, e_cmd;
const char *p_label, *p_data, *cp, *p_cmd;
pMenu = NULL;
for(;;)
{
p_label = NULL;
p_data = data;
if (0 == src->level) {
// read default menu from string
NextToken(line, &src->default_menu, "\n");
} else {
f = ReadNextCommand(src->fp[src->level-1], line, sizeof(line));
if (!f) {
if (src->level > 1) {
dec_inc_level(src);
continue; // continue from included file
}
e_cmd = e_no_end;
goto skip;
}
}
cp = replace_environment_strings(line, sizeof line);
//dbg_printf("Menu %08x line:%s", pMenu, line);
// get the command
if (false == get_string_within(command, sizeof command, &cp, "[]"))
continue;
// search the command
e_cmd = get_string_index(command, menu_cmds);
if (get_string_within(label, sizeof label, &cp, "()"))
p_label = label;
if (false == get_string_within(data, sizeof data, &cp, "{}"))
p_data = label;
skip:
if (NULL == pMenu)
{
if (e_begin == e_cmd) {
// If the line contains [begin] we create the menu
// If no menu title has been defined, display Blackbox version...
#ifdef BBXMENU
if (src->default_menu)
strcpy(label, "bbXMenu");
else
#endif
if (0 == label[0] && src->default_menu)
p_label = GetBBVersion();
pMenu = MakeNamedMenu(p_label, IDString, src->popup);
continue;
}
if (NULL == title)
title = NLS0("missing [begin]");
pMenu = MakeNamedMenu(title, IDString, src->popup);
}
pItem = NULL;
switch (e_cmd) {
//====================
// [begin] is like [submenu] when within the menu
case e_begin:
case e_submenu:
sprintf(buffer, "%s_%s", IDString, label);
_strlwr(buffer + strlen(IDString));
pSub = ParseMenu(src, p_data, buffer);
if (pSub)
pItem = MakeSubmenu(pMenu, pSub, label);
else
pItem = MakeMenuNOP(pMenu, label);
break;
//====================
case e_no_end:
MakeMenuNOP(pMenu, NLS0("missing [end]"));
case e_end:
MenuOption(pMenu, BBMENU_ISDROPTARGET);
return pMenu;
//====================
case e_include:
{
char dir[MAX_PATH];
file_directory(dir, src->path[src->level-1]);
replace_shellfolders_from_base(buffer, p_data, false, dir);
if (false == add_inc_level(src, buffer)) {
replace_shellfolders(buffer, p_data, false);
if (false == add_inc_level(src, buffer))
MakeMenuNOP(pMenu, NLS0("[include] failed"));
}
continue;
}
//====================
// a [nop] item will insert an inactive item with optional text
case e_nop:
pItem = MakeMenuNOP(pMenu, label);
break;
// a insert separator, we treat [sep] like [nop] with no label
case e_sep1:
case e_sep2:
pItem = MakeMenuNOP(pMenu, NULL);
break;
//====================
// a [path] item is pointing to a dynamic folder...
case e_path:
p_cmd = get_special_command(&p_data, buffer, sizeof buffer);
pItem = MakeMenuItemPath(pMenu, label, p_data, p_cmd);
break;
// a [insertpath] item will insert items from a folder...
case e_insertpath:
p_cmd = get_special_command(&p_data, buffer, sizeof buffer);
pItem = MakeMenuItemPath(pMenu, NULL, p_data, p_cmd);
break;
// a [stylemenu] item is pointing to a dynamic style folder...
case e_stylesmenu:
pItem = MakeMenuItemPath(pMenu, label, p_data, MM_STYLE_BROAM);
break;
// a [styledir] item will insert styles from a folder...
case e_stylesdir:
pItem = MakeMenuItemPath(pMenu, NULL, p_data, MM_STYLE_BROAM);
break;
// a [rcmenu] item is pointing to a dynamic rc files folder...
case e_rcmenu:
pItem = MakeMenuItemPath(pMenu, label, p_data, MM_EDIT_BROAM);
break;
case e_themesmenu:
pItem = MakeMenuItemPath(pMenu, label, p_data, MM_THEME_BROAM);
break;
//====================
// special items...
case e_workspaces:
pItem = MakeSubmenu(pMenu, MakeDesktopMenu(0, src->popup), p_label);
break;
case e_icons:
pItem = MakeSubmenu(pMenu, MakeDesktopMenu(1, src->popup), p_label);
break;
case e_tasks:
pItem = MakeSubmenu(pMenu, MakeDesktopMenu(2, src->popup), p_label);
break;
case e_config:
pItem = MakeSubmenu(pMenu, MakeConfigMenu(src->popup), p_label);
break;
//====================
case e_exec:
if ('@' == data[0]) {
pItem = MakeMenuItem(pMenu, label, data, false);
MenuItemOption(pItem, BBMENUITEM_UPDCHECK);
} else {
goto core_broam;
}
break;
//====================
case e_other:
f = get_workspace_number(command); // check for 'workspace1..'
if (-1 != f) {
pItem = MakeSubmenu(pMenu, MakeTaskFolder(f, src->popup), p_label);
} else {
p_data = data;
goto core_broam;
}
break;
//====================
// everything else is converted to a '@BBCore.xxx' broam
core_broam:
f = sprintf(buffer, "@bbCore.%s", command);
_strlwr(buffer+8);
if (p_data[0])
sprintf(buffer + f, " %s", p_data);
pItem = MakeMenuItem(pMenu, label[0]?label:command, buffer, false);
break;
}
//#ifdef BBOPT_MENUICONS
if ( Settings_menu.iconSize ) {
if (pItem && get_string_within(label, sizeof label, &cp, "<>"))
MenuItemOption(pItem, BBMENUITEM_SETICON, label);
}
//#endif
}
}
/*
* This function gets the string manufacturer name for the device. Note that this
* requires an explict call to the device which requires appropiate permissions
* to succeed. This function gets the string in the 1st language specified by
* the device. According to the USB spec, this is an UTF8 string.
*/
VALUE device_manufacturer(VALUE self)
{
struct usb_device *dev;
Data_Get_Struct(self, struct usb_device, dev);
return get_string_index(self, dev->descriptor.iManufacturer);
}
/*
* This function gets the string product name for the device. Note that this
* requires an explict call to the device which requires appropiate permissions
* to succeed. This function gets the string in the 1st language specified by
* the device. According to the USB spec, this is an UTF8 string.
*/
VALUE device_product_name(VALUE self)
{
struct usb_device *dev;
Data_Get_Struct(self, struct usb_device, dev);
return get_string_index(self, dev->descriptor.iProduct);
}
Error ResourceFormatSaverBinaryInstance::save(const String &p_path,const RES& p_resource,uint32_t p_flags) {
Error err;
if (p_flags&ResourceSaver::FLAG_COMPRESS) {
FileAccessCompressed *fac = memnew( FileAccessCompressed );
fac->configure("RSCC");
f=fac;
err = fac->_open(p_path,FileAccess::WRITE);
if (err)
memdelete(f);
} else {
f=FileAccess::open(p_path,FileAccess::WRITE,&err);
}
ERR_FAIL_COND_V(err,err);
FileAccessRef _fref(f);
relative_paths=p_flags&ResourceSaver::FLAG_RELATIVE_PATHS;
skip_editor=p_flags&ResourceSaver::FLAG_OMIT_EDITOR_PROPERTIES;
bundle_resources=p_flags&ResourceSaver::FLAG_BUNDLE_RESOURCES;
big_endian=p_flags&ResourceSaver::FLAG_SAVE_BIG_ENDIAN;
takeover_paths=p_flags&ResourceSaver::FLAG_REPLACE_SUBRESOURCE_PATHS;
if (!p_path.begins_with("res://"))
takeover_paths=false;
local_path=p_path.get_base_dir();
//bin_meta_idx = get_string_index("__bin_meta__"); //is often used, so create
_find_resources(p_resource,true);
if (!(p_flags&ResourceSaver::FLAG_COMPRESS)) {
//save header compressed
static const uint8_t header[4]={'R','S','R','C'};
f->store_buffer(header,4);
}
if (big_endian) {
f->store_32(1);
f->set_endian_swap(true);
} else
f->store_32(0);
f->store_32(0); //64 bits file, false for now
f->store_32(VERSION_MAJOR);
f->store_32(VERSION_MINOR);
f->store_32(FORMAT_VERSION);
//f->store_32(saved_resources.size()+external_resources.size()); // load steps -not needed
save_unicode_string(p_resource->get_type());
uint64_t md_at = f->get_pos();
f->store_64(0); //offset to impoty metadata
for(int i=0;i<14;i++)
f->store_32(0); // reserved
List<ResourceData> resources;
{
for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
ResourceData &rd = resources.push_back(ResourceData())->get();
rd.type=E->get()->get_type();
List<PropertyInfo> property_list;
E->get()->get_property_list( &property_list );
for(List<PropertyInfo>::Element *F=property_list.front();F;F=F->next()) {
if (skip_editor && F->get().name.begins_with("__editor"))
continue;
if (F->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && F->get().usage&PROPERTY_USAGE_BUNDLE)) {
Property p;
p.name_idx=get_string_index(F->get().name);
p.value=E->get()->get(F->get().name);
if (F->get().usage&PROPERTY_USAGE_STORE_IF_NONZERO && p.value.is_zero())
continue;
p.pi=F->get();
rd.properties.push_back(p);
}
}
}
}
f->store_32(strings.size()); //string table size
for(int i=0;i<strings.size();i++) {
//print_bl("saving string: "+strings[i]);
save_unicode_string(strings[i]);
}
// save external resource table
f->store_32(external_resources.size()); //amount of external resources
for(Set<RES>::Element *E=external_resources.front();E;E=E->next()) {
save_unicode_string(E->get()->get_save_type());
String path = E->get()->get_path();
save_unicode_string(path);
}
// save internal resource table
f->store_32(saved_resources.size()); //amount of internal resources
Vector<uint64_t> ofs_pos;
for(List<RES>::Element *E=saved_resources.front();E;E=E->next()) {
RES r = E->get();
if (r->get_path()=="" || r->get_path().find("::")!=-1) {
save_unicode_string("local://"+itos(ofs_pos.size()));
if (takeover_paths) {
r->set_path(p_path+"::"+itos(ofs_pos.size()),true);
}
} else
save_unicode_string(r->get_path()); //actual external
ofs_pos.push_back(f->get_pos());
f->store_64(0); //offset in 64 bits
}
Vector<uint64_t> ofs_table;
// int saved_idx=0;
//now actually save the resources
for(List<ResourceData>::Element *E=resources.front();E;E=E->next()) {
ResourceData & rd = E->get();
ofs_table.push_back(f->get_pos());
save_unicode_string(rd.type);
f->store_32(rd.properties.size());
for (List<Property>::Element *F=rd.properties.front();F;F=F->next()) {
Property &p=F->get();
f->store_32(p.name_idx);
write_variant(p.value,F->get().pi);
}
}
for(int i=0;i<ofs_table.size();i++) {
f->seek(ofs_pos[i]);
f->store_64(ofs_table[i]);
}
f->seek_end();
print_line("SAVING: "+p_path);
if (p_resource->get_import_metadata().is_valid()) {
uint64_t md_pos = f->get_pos();
Ref<ResourceImportMetadata> imd=p_resource->get_import_metadata();
save_unicode_string(imd->get_editor());
f->store_32(imd->get_source_count());
for(int i=0;i<imd->get_source_count();i++) {
save_unicode_string(imd->get_source_path(i));
save_unicode_string(imd->get_source_md5(i));
print_line("SAVE PATH: "+imd->get_source_path(i));
print_line("SAVE MD5: "+imd->get_source_md5(i));
}
List<String> options;
imd->get_options(&options);
f->store_32(options.size());
for(List<String>::Element *E=options.front();E;E=E->next()) {
save_unicode_string(E->get());
write_variant(imd->get_option(E->get()));
}
f->seek(md_at);
f->store_64(md_pos);
f->seek_end();
}
f->store_buffer((const uint8_t*)"RSRC",4); //magic at end
f->close();
return OK;
}
/*
* This function gets the string serial number for the device. Note that this
* requires an explict call to the device which requires appropiate permissions
* to succeed. This function gets the string in the 1st language specified by
* the device. According to the USB spec, this is an UTF8 string.
*/
VALUE device_serial_number(VALUE self)
{
struct usb_device *dev;
Data_Get_Struct(self, struct usb_device, dev);
return get_string_index(self, dev->descriptor.iSerialNumber);
}
void ResourceFormatSaverBinaryInstance::_find_resources(const Variant& p_variant,bool p_main) {
switch(p_variant.get_type()) {
case Variant::OBJECT: {
RES res = p_variant.operator RefPtr();
if (res.is_null())
return;
if (!p_main && (!bundle_resources ) && res->get_path().length() && res->get_path().find("::") == -1 ) {
external_resources.insert(res);
return;
}
if (resource_map.has(res))
return;
List<PropertyInfo> property_list;
res->get_property_list(&property_list);
for(List<PropertyInfo>::Element *E=property_list.front();E;E=E->next()) {
if (E->get().usage&PROPERTY_USAGE_STORAGE || (bundle_resources && E->get().usage&PROPERTY_USAGE_BUNDLE)) {
_find_resources(res->get(E->get().name));
}
}
resource_map[ res ] = saved_resources.size();
saved_resources.push_back(res);
} break;
case Variant::ARRAY: {
Array varray=p_variant;
int len=varray.size();
for(int i=0;i<len;i++) {
Variant v=varray.get(i);
_find_resources(v);
}
} break;
case Variant::DICTIONARY: {
Dictionary d=p_variant;
List<Variant> keys;
d.get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
_find_resources(E->get());
Variant v = d[E->get()];
_find_resources(v);
}
} break;
case Variant::NODE_PATH: {
//take the chance and save node path strings
NodePath np = p_variant;
for(int i=0;i<np.get_name_count();i++)
get_string_index(np.get_name(i));
for(int i=0;i<np.get_subname_count();i++)
get_string_index(np.get_subname(i));
get_string_index(np.get_property());
} break;
default: {}
}
}
void ResourceFormatSaverBinaryInstance::write_variant(const Variant& p_property,const PropertyInfo& p_hint) {
switch(p_property.get_type()) {
case Variant::NIL: {
f->store_32(VARIANT_NIL);
// don't store anything
} break;
case Variant::BOOL: {
f->store_32(VARIANT_BOOL);
bool val=p_property;
f->store_32(val);
} break;
case Variant::INT: {
f->store_32(VARIANT_INT);
int val=p_property;
f->store_32(val);
} break;
case Variant::REAL: {
f->store_32(VARIANT_REAL);
real_t val=p_property;
f->store_real(val);
} break;
case Variant::STRING: {
f->store_32(VARIANT_STRING);
String val=p_property;
save_unicode_string(val);
} break;
case Variant::VECTOR2: {
f->store_32(VARIANT_VECTOR2);
Vector2 val=p_property;
f->store_real(val.x);
f->store_real(val.y);
} break;
case Variant::RECT2: {
f->store_32(VARIANT_RECT2);
Rect2 val=p_property;
f->store_real(val.pos.x);
f->store_real(val.pos.y);
f->store_real(val.size.x);
f->store_real(val.size.y);
} break;
case Variant::VECTOR3: {
f->store_32(VARIANT_VECTOR3);
Vector3 val=p_property;
f->store_real(val.x);
f->store_real(val.y);
f->store_real(val.z);
} break;
case Variant::PLANE: {
f->store_32(VARIANT_PLANE);
Plane val=p_property;
f->store_real(val.normal.x);
f->store_real(val.normal.y);
f->store_real(val.normal.z);
f->store_real(val.d);
} break;
case Variant::QUAT: {
f->store_32(VARIANT_QUAT);
Quat val=p_property;
f->store_real(val.x);
f->store_real(val.y);
f->store_real(val.z);
f->store_real(val.w);
} break;
case Variant::_AABB: {
f->store_32(VARIANT_AABB);
AABB val=p_property;
f->store_real(val.pos.x);
f->store_real(val.pos.y);
f->store_real(val.pos.z);
f->store_real(val.size.x);
f->store_real(val.size.y);
f->store_real(val.size.z);
} break;
case Variant::MATRIX32: {
f->store_32(VARIANT_MATRIX32);
Matrix32 val=p_property;
f->store_real(val.elements[0].x);
f->store_real(val.elements[0].y);
f->store_real(val.elements[1].x);
f->store_real(val.elements[1].y);
f->store_real(val.elements[2].x);
f->store_real(val.elements[2].y);
} break;
case Variant::MATRIX3: {
f->store_32(VARIANT_MATRIX3);
Matrix3 val=p_property;
f->store_real(val.elements[0].x);
f->store_real(val.elements[0].y);
f->store_real(val.elements[0].z);
f->store_real(val.elements[1].x);
f->store_real(val.elements[1].y);
f->store_real(val.elements[1].z);
f->store_real(val.elements[2].x);
f->store_real(val.elements[2].y);
f->store_real(val.elements[2].z);
} break;
case Variant::TRANSFORM: {
f->store_32(VARIANT_TRANSFORM);
Transform val=p_property;
f->store_real(val.basis.elements[0].x);
f->store_real(val.basis.elements[0].y);
f->store_real(val.basis.elements[0].z);
f->store_real(val.basis.elements[1].x);
f->store_real(val.basis.elements[1].y);
f->store_real(val.basis.elements[1].z);
f->store_real(val.basis.elements[2].x);
f->store_real(val.basis.elements[2].y);
f->store_real(val.basis.elements[2].z);
f->store_real(val.origin.x);
f->store_real(val.origin.y);
f->store_real(val.origin.z);
} break;
case Variant::COLOR: {
f->store_32(VARIANT_COLOR);
Color val=p_property;
f->store_real(val.r);
f->store_real(val.g);
f->store_real(val.b);
f->store_real(val.a);
} break;
case Variant::IMAGE: {
f->store_32(VARIANT_IMAGE);
Image val =p_property;
if (val.empty()) {
f->store_32(IMAGE_ENCODING_EMPTY);
break;
}
int encoding=IMAGE_ENCODING_RAW;
float quality=0.7;
if (val.get_format() <= Image::FORMAT_INDEXED_ALPHA) {
//can only compress uncompressed stuff
if (p_hint.hint==PROPERTY_HINT_IMAGE_COMPRESS_LOSSY && Image::lossy_packer) {
encoding=IMAGE_ENCODING_LOSSY;
float qs=p_hint.hint_string.to_double();
if (qs!=0.0)
quality=qs;
} else if (p_hint.hint==PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS && Image::lossless_packer) {
encoding=IMAGE_ENCODING_LOSSLESS;
}
}
f->store_32(encoding); //raw encoding
if (encoding==IMAGE_ENCODING_RAW) {
f->store_32(val.get_width());
f->store_32(val.get_height());
f->store_32(val.get_mipmaps());
switch(val.get_format()) {
case Image::FORMAT_GRAYSCALE: f->store_32(IMAGE_FORMAT_GRAYSCALE ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
case Image::FORMAT_INTENSITY: f->store_32(IMAGE_FORMAT_INTENSITY ); break; ///< one byte per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255
case Image::FORMAT_GRAYSCALE_ALPHA: f->store_32(IMAGE_FORMAT_GRAYSCALE_ALPHA ); break; ///< two bytes per pixel: f->store_32(IMAGE_FORMAT_ ); break; 0-255. alpha 0-255
case Image::FORMAT_RGB: f->store_32(IMAGE_FORMAT_RGB ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B
case Image::FORMAT_RGBA: f->store_32(IMAGE_FORMAT_RGBA ); break; ///< one byte R: f->store_32(IMAGE_FORMAT_ ); break; one byte G: f->store_32(IMAGE_FORMAT_ ); break; one byte B: f->store_32(IMAGE_FORMAT_ ); break; one byte A
case Image::FORMAT_INDEXED: f->store_32(IMAGE_FORMAT_INDEXED ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*3 bytes of palette
case Image::FORMAT_INDEXED_ALPHA: f->store_32(IMAGE_FORMAT_INDEXED_ALPHA ); break; ///< index byte 0-256: f->store_32(IMAGE_FORMAT_ ); break; and after image end: f->store_32(IMAGE_FORMAT_ ); break; 256*4 bytes of palette (alpha)
case Image::FORMAT_BC1: f->store_32(IMAGE_FORMAT_BC1 ); break; // DXT1
case Image::FORMAT_BC2: f->store_32(IMAGE_FORMAT_BC2 ); break; // DXT3
case Image::FORMAT_BC3: f->store_32(IMAGE_FORMAT_BC3 ); break; // DXT5
case Image::FORMAT_BC4: f->store_32(IMAGE_FORMAT_BC4 ); break; // ATI1
case Image::FORMAT_BC5: f->store_32(IMAGE_FORMAT_BC5 ); break; // ATI2
case Image::FORMAT_PVRTC2: f->store_32(IMAGE_FORMAT_PVRTC2 ); break;
case Image::FORMAT_PVRTC2_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC2_ALPHA ); break;
case Image::FORMAT_PVRTC4: f->store_32(IMAGE_FORMAT_PVRTC4 ); break;
case Image::FORMAT_PVRTC4_ALPHA: f->store_32(IMAGE_FORMAT_PVRTC4_ALPHA ); break;
case Image::FORMAT_ETC: f->store_32(IMAGE_FORMAT_ETC); break;
case Image::FORMAT_ATC: f->store_32(IMAGE_FORMAT_ATC); break;
case Image::FORMAT_ATC_ALPHA_EXPLICIT: f->store_32(IMAGE_FORMAT_ATC_ALPHA_EXPLICIT); break;
case Image::FORMAT_ATC_ALPHA_INTERPOLATED: f->store_32(IMAGE_FORMAT_ATC_ALPHA_INTERPOLATED); break;
case Image::FORMAT_CUSTOM: f->store_32(IMAGE_FORMAT_CUSTOM ); break;
default: {}
}
int dlen = val.get_data().size();
f->store_32(dlen);
DVector<uint8_t>::Read r = val.get_data().read();
f->store_buffer(r.ptr(),dlen);
_pad_buffer(dlen);
} else {
DVector<uint8_t> data;
if (encoding==IMAGE_ENCODING_LOSSY) {
data=Image::lossy_packer(val,quality);
} else if (encoding==IMAGE_ENCODING_LOSSLESS) {
data=Image::lossless_packer(val);
}
int ds=data.size();
f->store_32(ds);
if (ds>0) {
DVector<uint8_t>::Read r = data.read();
f->store_buffer(r.ptr(),ds);
_pad_buffer(ds);
}
}
} break;
case Variant::NODE_PATH: {
f->store_32(VARIANT_NODE_PATH);
NodePath np=p_property;
f->store_16(np.get_name_count());
uint16_t snc = np.get_subname_count();
if (np.is_absolute())
snc|=0x8000;
f->store_16(snc);
for(int i=0;i<np.get_name_count();i++)
f->store_32(get_string_index(np.get_name(i)));
for(int i=0;i<np.get_subname_count();i++)
f->store_32(get_string_index(np.get_subname(i)));
f->store_32(get_string_index(np.get_property()));
} break;
case Variant::_RID: {
f->store_32(VARIANT_RID);
WARN_PRINT("Can't save RIDs");
RID val = p_property;
f->store_32(val.get_id());
} break;
case Variant::OBJECT: {
f->store_32(VARIANT_OBJECT);
RES res = p_property;
if (res.is_null()) {
f->store_32(OBJECT_EMPTY);
return; // don't save it
}
if (res->get_path().length() && res->get_path().find("::")==-1) {
f->store_32(OBJECT_EXTERNAL_RESOURCE);
save_unicode_string(res->get_save_type());
String path=relative_paths?local_path.path_to_file(res->get_path()):res->get_path();
save_unicode_string(path);
} else {
if (!resource_map.has(res)) {
f->store_32(OBJECT_EMPTY);
ERR_EXPLAIN("Resource was not pre cached for the resource section, bug?");
ERR_FAIL();
}
f->store_32(OBJECT_INTERNAL_RESOURCE);
f->store_32(resource_map[res]);
//internal resource
}
} break;
case Variant::INPUT_EVENT: {
f->store_32(VARIANT_INPUT_EVENT);
WARN_PRINT("Can't save InputEvent (maybe it could..)");
} break;
case Variant::DICTIONARY: {
f->store_32(VARIANT_DICTIONARY);
Dictionary d = p_property;
f->store_32(uint32_t(d.size())|(d.is_shared()?0x80000000:0));
List<Variant> keys;
d.get_key_list(&keys);
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
//if (!_check_type(dict[E->get()]))
// continue;
write_variant(E->get());
write_variant(d[E->get()]);
}
} break;
case Variant::ARRAY: {
f->store_32(VARIANT_ARRAY);
Array a=p_property;
f->store_32(uint32_t(a.size())|(a.is_shared()?0x80000000:0));
for(int i=0;i<a.size();i++) {
write_variant(a[i]);
}
} break;
case Variant::RAW_ARRAY: {
f->store_32(VARIANT_RAW_ARRAY);
DVector<uint8_t> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<uint8_t>::Read r = arr.read();
f->store_buffer(r.ptr(),len);
_pad_buffer(len);
} break;
case Variant::INT_ARRAY: {
f->store_32(VARIANT_INT_ARRAY);
DVector<int> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<int>::Read r = arr.read();
for(int i=0;i<len;i++)
f->store_32(r[i]);
} break;
case Variant::REAL_ARRAY: {
f->store_32(VARIANT_REAL_ARRAY);
DVector<real_t> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<real_t>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i]);
}
} break;
case Variant::STRING_ARRAY: {
f->store_32(VARIANT_STRING_ARRAY);
DVector<String> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<String>::Read r = arr.read();
for(int i=0;i<len;i++) {
save_unicode_string(r[i]);
}
} break;
case Variant::VECTOR3_ARRAY: {
f->store_32(VARIANT_VECTOR3_ARRAY);
DVector<Vector3> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Vector3>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].x);
f->store_real(r[i].y);
f->store_real(r[i].z);
}
} break;
case Variant::VECTOR2_ARRAY: {
f->store_32(VARIANT_VECTOR2_ARRAY);
DVector<Vector2> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Vector2>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].x);
f->store_real(r[i].y);
}
} break;
case Variant::COLOR_ARRAY: {
f->store_32(VARIANT_COLOR_ARRAY);
DVector<Color> arr = p_property;
int len=arr.size();
f->store_32(len);
DVector<Color>::Read r = arr.read();
for(int i=0;i<len;i++) {
f->store_real(r[i].r);
f->store_real(r[i].g);
f->store_real(r[i].b);
f->store_real(r[i].a);
}
} break;
default: {
ERR_EXPLAIN("Invalid variant");
ERR_FAIL();
}
}
}
void Toolbar_UpdatePosition(void)
{
int ScreenWidth;
int ScreenHeight;
int labelH, buttonH, tbheight, tbwidth, labelBorder;
int place, fontH;
HFONT hf;
struct toolbar_setting *tbs = &Settings_toolbar;
// Another Toolbar has set the info:
if (NULL == Toolbar_hwnd && TBInfo.hwnd)
return;
ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
place = get_string_index(tbs->placement, placement_strings);
if (-1 == place)
place = PLACEMENT_BOTTOM_CENTER;
// --- toolbar metrics ----------------------
hf = CreateStyleFont(&mStyle.Toolbar);
fontH = get_fontheight(hf);
DeleteObject(hf);
// xxx old behaviour xxx
if (false == mStyle.is_070
&& 0 == (mStyle.ToolbarLabel.validated & V_MAR))
fontH = mStyle.Toolbar.FontHeight-2;
//xxxxxxxxxxxxxxxxxxxxxx
labelBorder = imax(mStyle.ToolbarLabel.borderWidth,
imax(mStyle.ToolbarWindowLabel.borderWidth,
mStyle.ToolbarClock.borderWidth));
labelH = (fontH|1) + 2*(mStyle.ToolbarLabel.marginWidth/*+labelBorder*/);
buttonH = labelH + 2*(mStyle.ToolbarButton.marginWidth-mStyle.ToolbarLabel.marginWidth);
tbMargin = mStyle.Toolbar.marginWidth;
tbButtonWH = buttonH;
tbLabelH = labelH;
tbLabelIndent = imax(2+labelBorder, (labelH-fontH)/2);
tbheight = imax(labelH, buttonH) +
2*(mStyle.Toolbar.borderWidth + mStyle.Toolbar.marginWidth);
tbwidth = imax (300, ScreenWidth * tbs->widthPercent / 100);
// ------------------------------------------
TBInfo.placement = place;
TBInfo.widthPercent = tbs->widthPercent;
TBInfo.height = tbheight;
TBInfo.width = tbwidth;
TBInfo.ypos = (place<3) ? 0 : ScreenHeight - TBInfo.height;
TBInfo.xpos = (place%3) * (ScreenWidth - TBInfo.width) / 2;
TBInfo.onTop = tbs->onTop;
TBInfo.autoHide = tbs->autoHide;
TBInfo.pluginToggle = tbs->pluginToggle;
TBInfo.autohidden = TBInfo.autoHide;
TBInfo.alphaValue = (BYTE)tbs->alphaValue;
TBInfo.transparency = tbs->alphaEnabled;
TBInfo.disabled = false == tbs->enabled;
TBInfo.hidden = false == tbs->enabled;
if (Toolbar_hwnd)
{
int d = TBInfo.height - 1;
Toolbar_HideY = TBInfo.ypos + (place < 3 ? -d : d);
SetDesktopMargin(
Toolbar_hwnd,
place < 3 ? BB_DM_TOP : BB_DM_BOTTOM,
TBInfo.autoHide || Toolbar_hidden ? 0 : TBInfo.height);
tbClockW = 0;
Toolbar_setlabel();
Toolbar_setclock();
if (Toolbar_hFont) DeleteObject(Toolbar_hFont), Toolbar_hFont = NULL;
Toolbar_set_pos();
}
}
void Toolbar_UpdatePosition()
{
Settings_toolbarAlpha = Settings_toolbarAlphaEnabled ? Settings_toolbarAlphaValue : 255;
// Another Toolbar has set the info:
if (NULL == Toolbar_hwnd && TBInfo.hwnd) return;
int place = get_string_index(Settings_toolbarPlacement, placement_strings);
if (-1 == place) place = PLACEMENT_BOTTOM_CENTER;
// --- toolbar metrics ----------------------
int labelH, buttonH;
if (Settings_newMetrics || (mStyle.ToolbarLabel.validated & VALID_MARGIN))
{
HFONT hf = CreateStyleFont(&mStyle.Toolbar);
int lfh = get_fontheight(hf);
DeleteObject(hf);
if (mStyle.ToolbarLabel.validated & VALID_MARGIN)
labelH = lfh + 2 * mStyle.ToolbarLabel.marginWidth;
else
labelH = imax(10, lfh) + 2*2;
}
else
{
labelH = imax(8, mStyle.Toolbar.FontHeight) + 2;
}
labelH |= 1;
if (mStyle.ToolbarButton.validated & VALID_MARGIN)
{
buttonH = 9 + 2 * mStyle.ToolbarButton.marginWidth;
}
else
{
buttonH = labelH - 2;
}
tbMargin = mStyle.Toolbar.marginWidth;
tbButtonWH = buttonH;
tbLabelH = labelH;
int tbheight = imax(labelH, buttonH) +
2 * (mStyle.Toolbar.borderWidth + mStyle.Toolbar.marginWidth);
int tbwidth = imax (300, g_pVirtualWindowManager->GetPrimaryScreenSizeX() * Settings_toolbarWidthPercent / 100);
// ------------------------------------------
//int ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
//int ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
TBInfo.placement = place;
TBInfo.widthPercent = Settings_toolbarWidthPercent;
TBInfo.height = tbheight;
TBInfo.width = tbwidth;
TBInfo.ypos = (place<3) ? 0 : g_pVirtualWindowManager->GetPrimaryScreenSizeY() - TBInfo.height;
TBInfo.xpos = (place%3) * (g_pVirtualWindowManager->GetPrimaryScreenSizeX() - TBInfo.width) / 2;
TBInfo.onTop = Settings_toolbarOnTop;
TBInfo.autoHide = Settings_toolbarAutoHide;
TBInfo.pluginToggle = Settings_toolbarPluginToggle;
TBInfo.autohidden = TBInfo.autoHide;
TBInfo.alphaValue = Settings_toolbarAlphaValue;
TBInfo.transparency = Settings_toolbarAlphaEnabled;
TBInfo.disabled = false == Settings_toolbarEnabled;
TBInfo.hidden = false == Settings_toolbarEnabled;
if (Toolbar_hwnd)
{
int d = TBInfo.height - 1;
Toolbar_HideY = TBInfo.ypos + (place < 3 ? -d : d);
SetDesktopMargin(
Toolbar_hwnd,
place < 3 ? BB_DM_TOP : BB_DM_BOTTOM,
TBInfo.autoHide || Toolbar_hidden ? 0 : TBInfo.height + (TBInfo.onTop ? 0 : 4)
);
tbClockW = 0;
Toolbar_setlabel();
Toolbar_setclock();
if (Toolbar_hFont) DeleteObject(Toolbar_hFont), Toolbar_hFont = NULL;
Toolbar_set_pos();
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//controltype_label_message
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
int controltype_label_message(control *c, int tokencount, char *tokens[])
{
// token strings
enum
{
T_NONE = 0,
T_STYLE ,
T_VALIGN ,
T_HALIGN ,
T_HASTITLE ,
T_LOCKPOS ,
T_PLUGINLOAD ,
T_PLUGINUNLOAD ,
T_PLUGINSETPOS ,
T_PLUGINSHOW ,
T_PLUGINABOUT
};
extern char szWPStyle [];
static struct token_check controltype_label_property_tokens[] =
{
{ szWPStyle, T_STYLE , 1 },
{ "VAlign", T_VALIGN , 1 },
{ "HAlign", T_HALIGN , 1 },
{ "HasTitleBar", T_HASTITLE , 1 },
{ "IsLocked", T_LOCKPOS , 1 },
{ NULL }
};
static struct token_check controltype_label_plugin_property_tokens[] =
{
{ "IsVisible", T_PLUGINSHOW , 1 },
{ "Position", T_PLUGINSETPOS , 2 },
{ NULL }
};
static struct token_check controltype_label_plugin_tokens[] =
{
{ "Load", T_PLUGINLOAD , 1 },
{ "Unload", T_PLUGINUNLOAD , 1 },
{ "About", T_PLUGINABOUT , 0 },
{ szBActionPluginSetProperty, (UINT_PTR)controltype_label_plugin_property_tokens , 2 },
{ NULL }
};
static struct token_check controltype_label_message_tokens[] =
{
{ szBActionSetControlProperty, (UINT_PTR)controltype_label_property_tokens, 2 },
{ szBActionPlugin, (UINT_PTR)controltype_label_plugin_tokens, 2 },
{ NULL }
};
// -----------------
//Get the details
controltype_label_details *details = (controltype_label_details *) c->controldetails;
//If set control details
int i;
int curtok = 2;
switch (token_check(controltype_label_message_tokens, &curtok, tokencount, tokens))
{
// -----------------
case T_STYLE:
if (-1 != (i = get_string_index(tokens[curtok], szStyleNames)))
{
c->windowptr->style = i;
style_draw_invalidate(c);
return 0;
}
break;
// -----------------
case T_HALIGN:
if (-1 != (i = get_string_index(tokens[curtok], label_haligns)))
{
details->halign = i;
controltype_label_updatesettings(details);
style_draw_invalidate(c);
return 0;
}
break;
// -----------------
case T_VALIGN:
if (-1 != (i = get_string_index(tokens[curtok], label_valigns)))
{
details->valign = i;
controltype_label_updatesettings(details);
style_draw_invalidate(c);
return 0;
}
break;
// -----------------
case T_HASTITLE:
if (details->is_frame && config_set_bool(tokens[curtok], &details->has_titlebar))
{
style_draw_invalidate(c);
return 0;
}
break;
// -----------------
case T_LOCKPOS:
if (details->is_frame && config_set_bool(tokens[curtok], &details->is_locked))
return 0;
break;
// -----------------
case T_PLUGINLOAD:
if (details->is_frame)
{
char *plugin_name = tokens[curtok];
if (0 == strcmp(plugin_name, "*browse*"))
{
// "open file" dialog
plugin_name = dialog_file("Plugins\0*.dll\0", "Add Plugin" , NULL, ".dll", false);
if (NULL == plugin_name)
{
//message_override = true;
return 2;
}
}
ModuleInfo * m = loadPlugin(&details->module_info, c->windowptr->hwnd, plugin_name);
if (m)
{
variables_set(false, "LastPlugin", m->module_name);
return 0;
}
}
break;
// -----------------
case T_PLUGINUNLOAD:
if (unloadPlugin(&details->module_info, tokens[curtok]))
return 0;
break;
// -----------------
case T_PLUGINSETPOS:
{
int x, y;
if (config_set_int(tokens[curtok], &x)
&& config_set_int(tokens[1+curtok], &y)
&& plugin_setpos(details->plugin_info, tokens[-2+curtok], x, y)
)
return 0;
return 0; // dont generate an error here...
}
break;
// -----------------
case T_PLUGINSHOW:
{
bool show;
if (plugin_getset_show_state(details->plugin_info, tokens[-2+curtok],
config_set_bool(tokens[curtok], &show) ? show : 2)
)
return 0;
return 0; // dont generate an error here...
}
break;
// -----------------
case T_PLUGINABOUT:
{
aboutPlugins(details->module_info, c->controlname);
return 0;
}
break;
// -----------------
//Must be an agent message
default:
return agent_controlmessage(c, tokencount, tokens, CONTROLTYPE_LABEL_AGENT_COUNT, details->agents, controltype_label_agentnames, controltype_label_agenttypes);
}
return 1;
}