2011-06-05 03:45:04 +00:00
|
|
|
struct Timer::State {
|
|
|
|
bool enabled;
|
|
|
|
unsigned milliseconds;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
enabled = false;
|
|
|
|
milliseconds = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-24 09:25:20 +00:00
|
|
|
struct Window::State {
|
2011-08-06 14:03:52 +00:00
|
|
|
bool backgroundColorOverride;
|
|
|
|
Color backgroundColor;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool fullScreen;
|
|
|
|
Geometry geometry;
|
2011-09-05 03:48:23 +00:00
|
|
|
bool ignore;
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
set<Layout&> layout;
|
|
|
|
set<Menu&> menu;
|
2011-09-05 03:48:23 +00:00
|
|
|
string menuFont;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool menuVisible;
|
Update to v088r11 release.
byuu says:
Changelog:
- phoenix has added Window::setModal(bool modal = true);
- file dialog is now modal. This allows emulation cores to request data
and get it immediately before continuing the loading process
- save data is hooked up for most systems, still need to handle
subsystem slot saves (Sufami Turbo, basically.)
- toggle fullscreen key binding added (Alt+Enter for now. I think F11 is
probably better though, Enter is often mapped to game start button.)
- video scaling is in (center, scale, stretch), works the same in
windowed and fullscreen mode (stretch hides resize window option), all
in the settings menu now
- enough structure to map all saved paths for the browser and to load
BS-X slotted carts, BS-X carts, single Sufami Turbo carts
Caveats / Missing:
- Super Game Boy input doesn't work yet (due to change in callback
binding)
- doesn't load secondary Sufami Turbo slot yet
- BS-X BIOS isn't show the data pack games to load for some reason (ugh,
I hate the shit out of debugging BS-X stuff ...)
- need mute audio, sync audio+video toggle, save/load state menu and
quick keys, XML mapping information window
- need cheat editor and cheat database
- need state manager
- need to sort subsystems below main systems in load menu (basically
just see if media.slot.size() > 0)
- need video shaders (will probably leave off filters for the time being
... due to that 24/30-bit thing)
- need video adjustments (contrast etc, overscan masks)
- need audio adjustments (frequency, latency, resampler, volume,
per-system frequency)
- need driver selection and input focus policy (driver crash detection
would be nice too)
- need NSS DIP switch settings (that one will be really fun)
- need to save and load window geometry settings
- need to hook up controller selection (won't be fun), create a map to
hide controllers with no inputs to reassign
2012-05-03 12:36:47 +00:00
|
|
|
bool modal;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool resizable;
|
2011-09-05 03:48:23 +00:00
|
|
|
string statusFont;
|
2011-02-27 09:05:10 +00:00
|
|
|
string statusText;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool statusVisible;
|
2011-02-27 09:05:10 +00:00
|
|
|
string title;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool visible;
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
set<Widget&> widget;
|
2011-09-05 03:48:23 +00:00
|
|
|
string widgetFont;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
2011-08-06 14:03:52 +00:00
|
|
|
backgroundColorOverride = false;
|
Update to v088r11 release.
byuu says:
Changelog:
- phoenix has added Window::setModal(bool modal = true);
- file dialog is now modal. This allows emulation cores to request data
and get it immediately before continuing the loading process
- save data is hooked up for most systems, still need to handle
subsystem slot saves (Sufami Turbo, basically.)
- toggle fullscreen key binding added (Alt+Enter for now. I think F11 is
probably better though, Enter is often mapped to game start button.)
- video scaling is in (center, scale, stretch), works the same in
windowed and fullscreen mode (stretch hides resize window option), all
in the settings menu now
- enough structure to map all saved paths for the browser and to load
BS-X slotted carts, BS-X carts, single Sufami Turbo carts
Caveats / Missing:
- Super Game Boy input doesn't work yet (due to change in callback
binding)
- doesn't load secondary Sufami Turbo slot yet
- BS-X BIOS isn't show the data pack games to load for some reason (ugh,
I hate the shit out of debugging BS-X stuff ...)
- need mute audio, sync audio+video toggle, save/load state menu and
quick keys, XML mapping information window
- need cheat editor and cheat database
- need state manager
- need to sort subsystems below main systems in load menu (basically
just see if media.slot.size() > 0)
- need video shaders (will probably leave off filters for the time being
... due to that 24/30-bit thing)
- need video adjustments (contrast etc, overscan masks)
- need audio adjustments (frequency, latency, resampler, volume,
per-system frequency)
- need driver selection and input focus policy (driver crash detection
would be nice too)
- need NSS DIP switch settings (that one will be really fun)
- need to save and load window geometry settings
- need to hook up controller selection (won't be fun), create a map to
hide controllers with no inputs to reassign
2012-05-03 12:36:47 +00:00
|
|
|
backgroundColor = {0, 0, 0, 255};
|
2011-02-24 09:25:20 +00:00
|
|
|
fullScreen = false;
|
Update to v088r11 release.
byuu says:
Changelog:
- phoenix has added Window::setModal(bool modal = true);
- file dialog is now modal. This allows emulation cores to request data
and get it immediately before continuing the loading process
- save data is hooked up for most systems, still need to handle
subsystem slot saves (Sufami Turbo, basically.)
- toggle fullscreen key binding added (Alt+Enter for now. I think F11 is
probably better though, Enter is often mapped to game start button.)
- video scaling is in (center, scale, stretch), works the same in
windowed and fullscreen mode (stretch hides resize window option), all
in the settings menu now
- enough structure to map all saved paths for the browser and to load
BS-X slotted carts, BS-X carts, single Sufami Turbo carts
Caveats / Missing:
- Super Game Boy input doesn't work yet (due to change in callback
binding)
- doesn't load secondary Sufami Turbo slot yet
- BS-X BIOS isn't show the data pack games to load for some reason (ugh,
I hate the shit out of debugging BS-X stuff ...)
- need mute audio, sync audio+video toggle, save/load state menu and
quick keys, XML mapping information window
- need cheat editor and cheat database
- need state manager
- need to sort subsystems below main systems in load menu (basically
just see if media.slot.size() > 0)
- need video shaders (will probably leave off filters for the time being
... due to that 24/30-bit thing)
- need video adjustments (contrast etc, overscan masks)
- need audio adjustments (frequency, latency, resampler, volume,
per-system frequency)
- need driver selection and input focus policy (driver crash detection
would be nice too)
- need NSS DIP switch settings (that one will be really fun)
- need to save and load window geometry settings
- need to hook up controller selection (won't be fun), create a map to
hide controllers with no inputs to reassign
2012-05-03 12:36:47 +00:00
|
|
|
geometry = {128, 128, 256, 256};
|
2011-09-05 03:48:23 +00:00
|
|
|
ignore = false;
|
2011-02-24 09:25:20 +00:00
|
|
|
menuVisible = false;
|
Update to v088r11 release.
byuu says:
Changelog:
- phoenix has added Window::setModal(bool modal = true);
- file dialog is now modal. This allows emulation cores to request data
and get it immediately before continuing the loading process
- save data is hooked up for most systems, still need to handle
subsystem slot saves (Sufami Turbo, basically.)
- toggle fullscreen key binding added (Alt+Enter for now. I think F11 is
probably better though, Enter is often mapped to game start button.)
- video scaling is in (center, scale, stretch), works the same in
windowed and fullscreen mode (stretch hides resize window option), all
in the settings menu now
- enough structure to map all saved paths for the browser and to load
BS-X slotted carts, BS-X carts, single Sufami Turbo carts
Caveats / Missing:
- Super Game Boy input doesn't work yet (due to change in callback
binding)
- doesn't load secondary Sufami Turbo slot yet
- BS-X BIOS isn't show the data pack games to load for some reason (ugh,
I hate the shit out of debugging BS-X stuff ...)
- need mute audio, sync audio+video toggle, save/load state menu and
quick keys, XML mapping information window
- need cheat editor and cheat database
- need state manager
- need to sort subsystems below main systems in load menu (basically
just see if media.slot.size() > 0)
- need video shaders (will probably leave off filters for the time being
... due to that 24/30-bit thing)
- need video adjustments (contrast etc, overscan masks)
- need audio adjustments (frequency, latency, resampler, volume,
per-system frequency)
- need driver selection and input focus policy (driver crash detection
would be nice too)
- need NSS DIP switch settings (that one will be really fun)
- need to save and load window geometry settings
- need to hook up controller selection (won't be fun), create a map to
hide controllers with no inputs to reassign
2012-05-03 12:36:47 +00:00
|
|
|
modal = false;
|
2011-02-24 09:25:20 +00:00
|
|
|
resizable = true;
|
|
|
|
statusVisible = false;
|
|
|
|
visible = false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Action::State {
|
|
|
|
bool enabled;
|
2011-09-05 03:48:23 +00:00
|
|
|
Menu *menu;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool visible;
|
2011-09-05 03:48:23 +00:00
|
|
|
Window *window;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
enabled = true;
|
2011-09-05 03:48:23 +00:00
|
|
|
menu = 0;
|
2011-02-24 09:25:20 +00:00
|
|
|
visible = true;
|
2011-09-05 03:48:23 +00:00
|
|
|
window = 0;
|
2011-02-24 09:25:20 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Menu::State {
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
set<Action&> action;
|
2012-01-26 06:50:09 +00:00
|
|
|
nall::image image;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2012-01-26 06:50:09 +00:00
|
|
|
|
|
|
|
State() : image(0, 32, 255u << 24, 255u << 16, 255u << 8, 255u << 0) {
|
|
|
|
}
|
2011-02-24 09:25:20 +00:00
|
|
|
};
|
|
|
|
|
2011-02-27 09:05:10 +00:00
|
|
|
struct Item::State {
|
2012-01-15 08:29:57 +00:00
|
|
|
nall::image image;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2012-01-15 08:29:57 +00:00
|
|
|
|
|
|
|
State() : image(0, 32, 255u << 24, 255u << 16, 255u << 8, 255u << 0) {
|
|
|
|
}
|
2011-02-24 09:25:20 +00:00
|
|
|
};
|
|
|
|
|
2011-02-27 09:05:10 +00:00
|
|
|
struct CheckItem::State {
|
2011-02-24 09:25:20 +00:00
|
|
|
bool checked;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
checked = false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-27 09:05:10 +00:00
|
|
|
struct RadioItem::State {
|
2011-02-24 09:25:20 +00:00
|
|
|
bool checked;
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
set<RadioItem&> group;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
checked = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-09-05 03:48:23 +00:00
|
|
|
struct Sizable::State {
|
|
|
|
Layout *layout;
|
|
|
|
Window *window;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
layout = 0;
|
|
|
|
window = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Layout::State {
|
|
|
|
State() {
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-24 09:25:20 +00:00
|
|
|
struct Widget::State {
|
|
|
|
bool abstract;
|
|
|
|
bool enabled;
|
2011-09-05 03:48:23 +00:00
|
|
|
string font;
|
2011-02-24 09:25:20 +00:00
|
|
|
Geometry geometry;
|
|
|
|
bool visible;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
abstract = false;
|
|
|
|
enabled = true;
|
Update to v088r11 release.
byuu says:
Changelog:
- phoenix has added Window::setModal(bool modal = true);
- file dialog is now modal. This allows emulation cores to request data
and get it immediately before continuing the loading process
- save data is hooked up for most systems, still need to handle
subsystem slot saves (Sufami Turbo, basically.)
- toggle fullscreen key binding added (Alt+Enter for now. I think F11 is
probably better though, Enter is often mapped to game start button.)
- video scaling is in (center, scale, stretch), works the same in
windowed and fullscreen mode (stretch hides resize window option), all
in the settings menu now
- enough structure to map all saved paths for the browser and to load
BS-X slotted carts, BS-X carts, single Sufami Turbo carts
Caveats / Missing:
- Super Game Boy input doesn't work yet (due to change in callback
binding)
- doesn't load secondary Sufami Turbo slot yet
- BS-X BIOS isn't show the data pack games to load for some reason (ugh,
I hate the shit out of debugging BS-X stuff ...)
- need mute audio, sync audio+video toggle, save/load state menu and
quick keys, XML mapping information window
- need cheat editor and cheat database
- need state manager
- need to sort subsystems below main systems in load menu (basically
just see if media.slot.size() > 0)
- need video shaders (will probably leave off filters for the time being
... due to that 24/30-bit thing)
- need video adjustments (contrast etc, overscan masks)
- need audio adjustments (frequency, latency, resampler, volume,
per-system frequency)
- need driver selection and input focus policy (driver crash detection
would be nice too)
- need NSS DIP switch settings (that one will be really fun)
- need to save and load window geometry settings
- need to hook up controller selection (won't be fun), create a map to
hide controllers with no inputs to reassign
2012-05-03 12:36:47 +00:00
|
|
|
geometry = {0, 0, 0, 0};
|
2011-02-24 09:25:20 +00:00
|
|
|
visible = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Button::State {
|
2012-01-15 08:29:57 +00:00
|
|
|
nall::image image;
|
|
|
|
Orientation orientation;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
2012-01-15 08:29:57 +00:00
|
|
|
State() : image(0, 32, 255u << 24, 255u << 16, 255u << 8, 255u << 0) {
|
2011-02-24 09:25:20 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-11-04 11:57:54 +00:00
|
|
|
struct Canvas::State {
|
|
|
|
uint32_t *data;
|
|
|
|
unsigned width;
|
|
|
|
unsigned height;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
data = nullptr;
|
|
|
|
width = 256;
|
|
|
|
height = 256;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-24 09:25:20 +00:00
|
|
|
struct CheckBox::State {
|
|
|
|
bool checked;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
checked = false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ComboBox::State {
|
|
|
|
unsigned selection;
|
2011-10-16 09:44:48 +00:00
|
|
|
vector<string> text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
selection = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct HexEdit::State {
|
|
|
|
unsigned columns;
|
|
|
|
unsigned length;
|
|
|
|
unsigned offset;
|
|
|
|
unsigned rows;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
columns = 16;
|
|
|
|
length = 0;
|
|
|
|
offset = 0;
|
|
|
|
rows = 16;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-08-06 14:03:52 +00:00
|
|
|
struct HorizontalScrollBar::State {
|
|
|
|
unsigned length;
|
|
|
|
unsigned position;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
length = 101;
|
|
|
|
position = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-24 09:25:20 +00:00
|
|
|
struct HorizontalSlider::State {
|
|
|
|
unsigned length;
|
|
|
|
unsigned position;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
length = 101;
|
|
|
|
position = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Label::State {
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct LineEdit::State {
|
|
|
|
bool editable;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
editable = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ListView::State {
|
|
|
|
bool checkable;
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
vector<bool> checked;
|
2011-02-27 09:05:10 +00:00
|
|
|
lstring headerText;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool headerVisible;
|
2012-06-18 10:13:51 +00:00
|
|
|
vector<vector<nall::image>> image;
|
2011-02-27 09:05:10 +00:00
|
|
|
bool selected;
|
|
|
|
unsigned selection;
|
2011-10-16 09:44:48 +00:00
|
|
|
vector<lstring> text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
2011-02-27 09:05:10 +00:00
|
|
|
State() {
|
2011-02-24 09:25:20 +00:00
|
|
|
checkable = false;
|
|
|
|
headerVisible = false;
|
2011-02-27 09:05:10 +00:00
|
|
|
selected = false;
|
|
|
|
selection = 0;
|
2011-02-24 09:25:20 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ProgressBar::State {
|
|
|
|
unsigned position;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
position = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct RadioBox::State {
|
|
|
|
bool checked;
|
Update to v088r02 release.
byuu says:
Basically, the current implementation of nall/array is deprecated now.
The old method was for non-reference types, it acted like a vector for
POD types (raw memory allocation instead of placement new construction.)
And for reference types, it acted like an unordered set. Yeah, not good.
As of right now, nall/array is no longer used. The vector type usage was
replaced with actual vectors.
I've created nall/set, which now contains the specialization for
reference types.
nall/set basically acts much like std::unordered_set. No auto-sort, only
one of each type is allowed, automatic growth.
This will be the same both for reference and non-reference types ...
however, the non-reference type wasn't implemented just yet.
Future plans for nall/array are for it to be a statically allocated
block of memory, ala array<type, size>, which is meant for RAII memory
usage.
Have to work on the specifics, eg the size as a template parameter may
be problematic. I'd like to return allocated chunks of memory (eg
file::read) in this container so that I don't have to manually free the
data anymore.
I also removed nall/moduloarray, and moved that into the SNES DSP class,
since that's the only thing that uses it.
2012-04-26 10:56:15 +00:00
|
|
|
set<RadioBox&> group;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
|
|
|
|
State() {
|
|
|
|
checked = true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
struct TextEdit::State {
|
|
|
|
unsigned cursorPosition;
|
|
|
|
bool editable;
|
2011-02-27 09:05:10 +00:00
|
|
|
string text;
|
2011-02-24 09:25:20 +00:00
|
|
|
bool wordWrap;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
cursorPosition = 0;
|
|
|
|
editable = true;
|
Update to v085r08 release.
byuu says:
Changelog:
- follow the Laevateinn topic to get most of it
- also added NMI, IRQ step buttons to CPU debugger
- also added trace masking + trace mask reset
- also added memory export
- cartridge loading is entirely folder-based now
FitzRoy, I'll go ahead and make a second compromise with you for v086:
I'll match the following:
/path/to/SNES.sfc/*.sfc
/path/to/NES.fc/*.prg, *.chr (split format)
/path/to/NES.fc/*.fc (merged format)
/path/to/GB.gb/*.gb
/path/to/GBC.gbc/*.gbc
Condition will be that there can only be one of each file. If there's
more than one, it'll abort. That lets me name my ROMs as
"Game.fc/Game.fc", and you can name yours as "Game.fc/cartridge.prg,
cartridge.chr". Or whatever you want.
We'll just go with that, see what fares out as the most popular, and
then restrict it back to that method.
The folder must have the .fc, etc extension though. That will be how we
avoid false-positive folder matches.
[Editor's note - the Laevateinn topic mentions these changes for
v085r08:
Added SMP/PPU breakpoints, SMP debugger, SMP stepping / tracing,
memory editing on APU-bus / VRAM / OAM / CGRAM, save state menu,
WRAM mirroring on breakpoints, protected MMIO memory regions
(otherwise, viewing $002100 could crash your game.)
Major missing components:
- trace mask
- trace mask clear / usage map clear
- window geometry caching / sizing improvements
- VRAM viewer
- properties viewer
- working memory export button
The rest will most likely appear after v086 is released.
]
2012-02-12 05:35:40 +00:00
|
|
|
wordWrap = true;
|
2011-02-24 09:25:20 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-08-06 14:03:52 +00:00
|
|
|
struct VerticalScrollBar::State {
|
|
|
|
unsigned length;
|
|
|
|
unsigned position;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
length = 101;
|
|
|
|
position = 0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-02-24 09:25:20 +00:00
|
|
|
struct VerticalSlider::State {
|
|
|
|
unsigned length;
|
|
|
|
unsigned position;
|
|
|
|
|
|
|
|
State() {
|
|
|
|
length = 101;
|
|
|
|
position = 0;
|
|
|
|
}
|
|
|
|
};
|