| 1fb460987f7d832adf12290f41448d0c16a95972 |
|
20-Sep-2012 |
Siva Velusamy <vsiva@google.com> |
Move some utility functions from AdtUtils to common
Change-Id: Ia6f5c55e07c7f60712472c8e850b7c4595c46671
|
| 12d4581faa6438941e65a9dc83213be34c6ca970 |
|
13-Sep-2012 |
Tor Norbye <tnorbye@google.com> |
Constants refactoring.
This changeset moves most constants into the SdkConstants
class, and gets rid of AndroidConstants and LintConstants.
It also migrates all non-ADT specific constants from
AdtConstants into SdkConstants. It furthermore moves various
other constants (such as those in XmlUtils and ValuesDescriptors)
into the constants class. It also fixes the modifier order
to be the canonical modifier order (JLS 8.x).
Finally, it removes redundancy and combines various constant
aliases such that we don't have both NAME_ATTR and ATTR_NAME
pointing to "name", etc.
Change-Id: Ifd1755016f62ce2dd80e5c76130d6de4b0e32161
|
| 81cefe2a26dd6db8a878e30874d12cdcbff0e83b |
|
11-Aug-2012 |
Xavier Ducrohet <xav@android.com> |
More refactoring.
Move stuff out of sdklib into common and ide_common.
Remove androidprefs and move the one class into common.
Change-Id: I71d126a13cf2ba413692e29616f4968a37d7b33a
|
| 85e4a1a9dd133abb879ec211ce8dd385004edf22 |
|
08-Aug-2012 |
Xavier Ducrohet <xav@android.com> |
Refactor common.jar
Move resources and com.android.util.Pair into layoutlib_api
where they belong since layoutlib depends on them and we need
to control the API.
Made a copy of Pair to stay in common.jar but moved it to
com.android.utils.Pair (the one in com.android.util.Pair is
marked as deprecated to prevent usage where applicable).
Also moved XmlUtil and PositionXmlParser to com.android.utils
to match Pair.
Change-Id: I21d7057d3f2ce604f86a3bb1fa3c130948c93b89
|
| a881b0b34678ad76c9f5eba62fac7a00a22ac606 |
|
20-May-2012 |
Tor Norbye <tnorbye@google.com> |
Move XML code to the common library
The ManifestMerger library needs to look up the prefix to use for the
Android namespace, and the Document.lookupPrefix method is not
implemented by the Eclipse DOM implementation (which throws an
exception). However, we have an implementation of this in the ADT
plugin.
This changeset creates a new XmlUtils class in the common/ library
(which is accessible by both ADT and the manifest merger, and the
anttasks where the manifest merger is used), and moves the namespace
prefix lookup code in there. It also moves the XML escape methods
into that class. It also adds a new method to the ManifestMerger for
merging directly from documents (rather than files), and makes sure
that all the merging code goes via the prefix utility method rather
than calling the document.lookupPrefix method.
Finally, it moves the various string constants associated with XML
namespaces into the single XmlUtils class, since these were spread
across several different classes before (and many of them are needed
in the XmlUtils class).
The vast majority of the diffs in this changeset are related to simple
import statement changes to reflect the new locations of these
constants.
Change-Id: Ib8f3d0e5c89e47e61ea509a23925af7b6580abee
|
| 6681db8624e514030730e3c52192330aec5279a9 |
|
10-May-2012 |
Tor Norbye <tnorbye@google.com> |
Fix issue 30529: Ensure that XML editor uses platform line separators
Change-Id: I5c4fa6273ce14f4682e9e7fa9a8fbe9f8cdc8d46
|
| 57f1244facb6c3de1fe8011ab66cdc3dd9ce0b61 |
|
26-Apr-2012 |
Tor Norbye <tnorbye@google.com> |
Make XML code completion work for custom views & attributes
This changeset improves the custom view handling such that XML code
completion offers any custom attributes (along with documentation
tooltips and type information). This is done by finding any
declare-styleable attributes defined in the project defining the
custom view. In particular, this will also work for the GridLayout
library project shipped as part of the android.support package.
The fix is not tied to completion; it's improving the metadata
descriptors computed for custom views, so this fix for example also
makes these custom attributes show up in the property sheet in the
layout editor.
Finally, this changeset fixes a couple of bugs in this area:
- One initialization path was not looking up custom views for unknown
descriptors, this might be the fix for
http://code.google.com/p/android/issues/detail?id=23020
- There was a bug in the code which looks up the namespace prefix to
use for a given namespace URI: it would return the default Android
prefix for some non-Android URIs.
- Small performance tweak to avoid regexp construction in a loop where
it's not needed
Change-Id: I55dfcea6e6ea9d7c38e18a47b757678176facbd2
|
| 9bd06947302ca6ca3e0b90eef894e553c6c3e067 |
|
05-Apr-2012 |
Tor Norbye <tnorbye@google.com> |
Add support for the WindowBuilder Property Sheet
This reverts commit 27dac06bfc4297dc9a018edc534f44ecf96cd724.
Change-Id: I6708bd4091f0cb677484669479357d479b9db5fa
|
| 27dac06bfc4297dc9a018edc534f44ecf96cd724 |
|
03-Apr-2012 |
Tor Norbye <tnorbye@google.com> |
Revert "Add support for the WindowBuilder Property Sheet"
This reverts commit a7621238bf0202419677380ee3a268142358df83.
|
| a7621238bf0202419677380ee3a268142358df83 |
|
20-Mar-2012 |
Tor Norbye <tnorbye@google.com> |
Add support for the WindowBuilder Property Sheet
The WindowBuilder propertysheet has been extracted and added as a
library in external/eclipse-windowbuilder/.
This changeset removes the old propertysheet code (which used the
builtin Eclipse property sheet page), and replaces it with the
WindowBuilder one, along with new code to aggregate the properties
into some categories, as well as tagging some of the properties as
advanced. (This was computed by running the same analysis scripts used
to produce the most-frequent attributes (sdk/attribute_stats) and
instead computing which attributes are used very infrequently or not
at all in some representative sample code.)
The WindowBuilder propertysheet gives us the following new features:
- Highlighting (bold) of important attributes
- Masking (and when included, shown in gray italic) of advanced
attributes
- "Complex" attributes with nesting, used to for example aggregate all
the layout parameters into a single node, and the margin layout
attributes within those
- Tooltips over the attribute names, not values, so they never obscure
content
In addition, this changeset adds custom implementations of properties,
property editors and property dialogs for the core Android property
types (XML strings, flags and booleans), which adds the following new
features:
- Preview rendering of color and image resources inline
- Display of -default- attributes (those not specified in XML) using
the layoutlib facility getDefaultProperties() to render the implied
attributes. For example, if you look at a Button, it will show you
that the implied value of "Text Color Link" is
"@android:color/holo_blue_light" even though it is not set.
NOTE: This only happens for attributes that were actually queried by
the widget during rendering. Attributes that are not used by the
widget have no (displayed) value. Thus, EditText-specific attributes
in a TextView are not shown when a non-EditText TextView is
selected.
- Evaluation of the attributes. In the above example, in addition to
showing @android:color/holo_blue_light, it will chase down the value
of this to for example render a blue square next to the value. For
drawables it will render a thumbnail, and for String resources it
will display the actual value in parentheses.
- Field completion in text fields, completing all resource strings
(@string, @android:string, etc), as well as flag values. Enum values
are chosen in a dropdown.
- Checkbox support for boolean values, allowing you to click through
the three values true, false and null.
- Our custom version of the Property Sheet Page allows you to
expand/collapse all properties, and it also has an option letting
you switch between Alphabetical Sort (where all attributes are in a
flat table, sorted alphabetically by property value), or
hierarchical sorted "by category". Currently the categories are
simply the defining views, plus 2 more (layout parameters and
deprecated attributes). When we get more metadata, it would be nice
to switch these to more logical categories, such as "text",
"scrolling", "focus", etc. (There is some preliminary support for
this in the code, but since the defining-view categories seem to
work better those are used instead right now.)
Change-Id: Ie4959a3a2c36c083dcc1ba19a70f24b33739fe2f
|
| 61684adfd7345f1a0df24bcf9176e6f528295bbb |
|
22-Mar-2012 |
Tor Norbye <tnorbye@google.com> |
Change AttributeInfo.getFormats() to returning an EnumSet<Format>
This changeset changes the signature of AttributeInfo.getFormats()
from returning a Format[] to returning an EnumSet<Format>.
Furthermore, it defines a number of constants for the various common
format sets such that they can be reused.
Nearly all uses of the getFormats() method was really just trying to
see "is format X among the formats", so using enumsets is more natural
since it has a contains method. This also lets us replace some
attribute init code which was building up a set from the array for
this exact same purpose just reuse the format set directly.
In the attribute parser, rather than computing the uppercase version
of each format string ("dimension"=>"DIMENSION") and then doing a
Format.valueOf("DIMENSION"), we now compute a map for all the format
constants as lowercase to the corresponding format instance, and use
that map when parsing the attrs.xml file.
Note that there is a small semantic change from having an array of
formats to using an enumset: The format specified an
ordering. However, it does not look like any code depended on this,
and it's also not clear that the ordering in attrs.xml is
intentional. For example, it contains both "color|reference" and
"reference|color", and in both cases the intent is that the attribute
can specify an actual color or a reference to a color. Now with an
enum set, the order used when traversing the formats will always be in
their natural order, and for this purpose the REFERENCE type is moved
to the end since it's the least specific.
Change-Id: I1170cff48086f5cc13e4b70a35deea1f9979c883
|
| 6b09013b6cb0fdcb48350a60bb3ed924ac9f562d |
|
22-Mar-2012 |
Tor Norbye <tnorbye@google.com> |
Speed up Android Target Data loading
This changeset optimizes the handling of AttributeDescriptors during
the SDK target loading phase. From some simple benchmarks, this
speeds up target loading about 40%. (On an low-load machine, loading
two targets took on average 9.11s with standard deviation 1.86 for 13
runs; after the fix the same target loading took on average 6.359s
with standard deviation 0.944s for 17 runs -- so the speedup is 1.43).
The most important fix is to make the computation of the tooltip text
and the UI name (which performs various lowercase to uppercase
conversions, in some cases involving regular expressions, and many
string concatentations) be evaluated lazily. This is a big win since
most attributes never have their UI names or tooltips displayed, and
when they are, usually just a small number.
Since tooltips and UI names are now computed lazily from the
AttributeInfo, the constructor for the TextAttributeDescriptor and its
subclasses no longer take a UI name or tooltip; instead, there is an
explicit setter for the cases where you have a specific tooltip you
want to hardcode (as with the builtin descriptors such as the ones for
drawables).
The actual formatting method for UI names was also optimized a bit,
such as avoiding regexp replacements except for cases where they are
likely needed, preallocating a larger character buffer, etc.
Change-Id: I7004e403fcf696e18bd89a29c6cfd27b61c1e9f8
|
| 3e75d4f79a8328ed18505830c786402369082efa |
|
06-Mar-2012 |
Tor Norbye <tnorbye@google.com> |
Make GridLayout support work with the support library
Also fix the paste operation to target the parent if
the paste target does not accept children.
Change-Id: Id084db376e5ff9b4a374e6d2145bc890a925a078
|
| 69067f399231dc28f4ff0aa02b60153ffd2d5831 |
|
06-Feb-2012 |
Tor Norbye <tnorbye@google.com> |
Add support for suppressing lint via XML attributes
This changeset adds support for suppressing in XML files:
(1) Lint will ignore errors found in attributes and elements if the
element (or any surrounding parent elements) specifies a
tools:ignore="id-list" attribute where the id-list matches the id
of the reported issue (or "all"). The "tools" prefix can be any
prefix bound to the namespace "http://schemas.android.com/tools"
(2) There's a new quickfix shown for XML lint warnings which offers to
add a lint suppress attribute for a given lint warning (setting
the id to the id of the warning, and adding the tools namespace
binding if necessary).
(3) The XML formatter now handles namespaces a bit better: after the
preferred attributes (id, name, style, layout params, etc) have
been handled, attributes are sorted by namespace prefix before
they are sorted by local name -- which effectively will sort any
new tools:ignore attributes to the end.
Change-Id: Id7474cde5665d9bd29bdd4e0d0cc89ed4d422aea
|
| bc083393e77f8139a436683644065e396646d671 |
|
21-Jan-2012 |
Raphael <raphael@google.com> |
ADT: Refactor editors.xml and editors.resources.
This renames:
- xml.XmlEditor to otherxml.OtherXmlEditor,
- resources.ResourcesEditor to values.ValuesEditor
The change to rename Resources to Values matches
the folder name being /res/values.
That's just a trivial refactoring with no logic change.
Change-Id: I68bfa760f254fbbd3f2d5e3801a5092308e92f7f
|
| 91069c28195ca0ed5e64f36714cf359f63743710 |
|
18-Jan-2012 |
Raphael <raphael@google.com> |
ADT: adjust default-editor id for existing legacy editors.
Note that this changes the "default editor" id associated
by a file but not actually close an existing editor (trying
to do so from the editor fails.) Also, unless the editor
is put in focus, it is not initialized and thus will not
change.
To compensate, when opening a project we'll visit all the
XML files from the /res folder and associate them to our
new editor ID.
On top of that, we'll try to find existing open editors
using a legacy id and close/reopen them using the new
common editor id. We only do that when upgrading a project
via fixEditorAssiociations, which means if the user then
manually forces a file to open using a legacy editor
by using the Open With > Other, it will keep using the
old editor id and we won't open/close it a second time.
Change-Id: Ia5f7e960515500a0ad07d401124578477ed70859
|
| 4c07263da057b6014342089097a3a4c6ebe993d2 |
|
10-Jan-2012 |
Raphael <raphael@google.com> |
ADT: single base class for XML editors.
This re-architecture the way the various XML editors are
handled by ADT.
Before, we had various classes all deriving from AndroidXmlEditor,
all listed in the plugin.xml as handled the "xml" extension. The
right one was set by AdtPlugin when monitoring changed resources.
The new structure is to have a single AndroidXmlCommonEditor.
This derives from AndroidXmlEditor right now, but in phase 2 will
merge them back in a single class.
Each XML editor implements an XmlEditDelegate. The
delegator iterates through the delegates to find the correct
one that can handle a given file and then uses it.
After this CL, we'll need a few extra passes:
- Understand what all editors delegates are doing
and merge it in the base class. There's currently a bit
of code duplicationg we could avoid.
- Change the ManifestEditor to the new structure.
- Change LayoutEditor to the new structure (already prepared
but in a different CL)
Change-Id: I6cb045a8fa39386fcc0ce854b45fa8580fae411e
|
| 18bce12c5916331971b2e8108f8485cc56b696d3 |
|
06-Jan-2012 |
Tor Norbye <tnorbye@google.com> |
Fix locale handling of uppercase/lowercase
This changeset fixes issue
23747: i and İ character problem in turkish operating Systems...
and probably many other bugs in the Turkish locale.
Basically, we had a lot of String.toLowerCase() and
String.toUpperCase() calls. This performs locale sensitive
conversions, which in many cases is NOT what we want; for "machine
readable" conversions we should be using Locale.US which performs no
special cases.
For more, see
http://developer.android.com/reference/java/util/Locale.html#default_locale
Change-Id: I996b0e70fb377e8dae484c5811deb8bc9afb684c
|
| ab36f4e7488358dea4ab6b54ee2b7bef3da0232b |
|
21-Dec-2011 |
Tor Norbye <tnorbye@google.com> |
Update SDK codebase to JDK 6
This changeset makes the SDK codebase compile with source=1.6 (which
means it also requires JDK 6). This means that methods implementing an
interface requires @Override's. It also means we can start using APIs
like the ArrayDeque class and methods like String#isEmpty().
This changeset looks big but the change is trivial: it's basically
adding @Override in all the places that need it, along with some other
automatic Eclipse cleanup in certain files (such as reordering imports
where they were incorrectly ordered (because older versions of Eclipse
didn't always handle inner classes right)), as well as cleaning up
trailing whitespace and removing some $NON-NLS-1$ markers on lines
where there aren't any string literals anymore.
This changeset also sets the source and target JDK level to 6 in the
Eclipse compiler .settings file, and synchronizes this file to all the
other Eclipse SDK projects.
Change-Id: I6a9585aa44c3dee9a5c00739ab22fbdbcb9f8275
|
| 556f4bc4717cad7d116d85fe41301bc57feec7eb |
|
24-Nov-2011 |
Tor Norbye <tnorbye@google.com> |
Fix for custom view rendering with auto-format, revisited
This changeset revisits
http://code.google.com/p/android/issues/detail?id=21750
"Layout editor auto-formatting breaks rendering of custom views"
The bug described in the issue is that dragging custom views into the
canvas does not trigger a render until you save the file. My initial
bug fix noted that we actually would get *two* render requests, and
the second render was blank, so I fixed the model notifications such
that only a single notification (triggering a render) was sent.
However, collapsing the two changeModel calls into the DOM model
turned out to have some adverse effects when auto-format was enabled,
so I turned off auto-format until I could track the bug down.
In this changeset I'm turning it back on, and fixing the root cause
which made the custom view not appear: in the XML DOM to UI Model
sync, no descriptor was found for the custom view so the node simply
wasn't added to the model.
We still don't want multiple notifications (and therefore renders), so
I'm also changing the notifications structure a bit. Now a single
notification is made after all the edit hooks are run, and after the
edit lock has been released (it grabs a read lock instead for the
duration of the notification phase).
Change-Id: I2281dc936bf0442e2d38ac2750e81a8f120a924e
|
| 567a8dbd43e9885fc66aed463121c05cd3d17e5d |
|
09-Nov-2011 |
Tor Norbye <tnorbye@google.com> |
Remove "unknown element" logging message
If you open the Error Log, and then go to (for example) a layout XML
file and type in a new tag, character by character, you will see that
the error log quickly fills up with messages of the form:
!ENTRY com.android.ide.eclipse.adt 2 0 2011-11-08 16:33:10.773
!MESSAGE AndroidManifest: Ignoring unknown 'Li' XML element
!ENTRY com.android.ide.eclipse.adt 2 0 2011-11-08 16:33:10.885
!MESSAGE AndroidManifest: Ignoring unknown 'Line' XML element
!ENTRY com.android.ide.eclipse.adt 2 0 2011-11-08 16:33:11.372
!MESSAGE AndroidManifest: Ignoring unknown 'Linear' XML element
What's happening is that on each keystroke, the UI model is updated,
and it complains if it sees element names that it does not recognize
from the descriptors. However, during an interactive edit it's normal
to have incomplete tag names, so we shouldn't complain -- aapt will do
that when the file is finally saved and processed.
Change-Id: Ib314ed0e1e17e69e35f05858ced5043fca2c29f3
|
| 150f02bff38df2320a954c20b4d0f5b41dd50e79 |
|
20-Oct-2011 |
Tor Norbye <tnorbye@google.com> |
Handle node identity changes
This changeset fixes a bug where sometimes dropping a new widget into
a layout would cause lots of other widget to be selected as well.
The root cause is that Eclipse's DOM *sometimes* decides to throw away
and replace all the children of a node, even when most of the children
just had attribute changes. In particular, this happens in some
GridLayout scenarios where a drop causes many attribute changes on the
children (to update row and column indices etc).
The workaround has two parts:
(1) The old implementation would find out which nodes were added by a
drop handler by storing a list of all the children before the
drop, then getting the list after the drop and removing the ones
that were present before.
This doesn't work when node ids change since *all* the children
would get marked as "new".
To address this, I made tracking created nodes more explicit:
rather than "diffing" the lists, there's a NodeCreationListener
interface you can hook into which (while you're listening) will
tell you about *all* nodes created by any parent. In the drop
handler we add a listener and make a list of all newly added nodes
that have the drop target node as a parent.
(2) Even with an explicit list of which nodes were added, there's the
problem that the nodes that were added have changed their
identities, so we cannot look up a "view rectangle" for them and
select them in the layout editor. To do this we need ot map from
the previous children of a parent node to its new children. We
cannot make the comparison based on equality (since the reason
we're getting into this trouble in the first place is that the
various children are touched by the drop handler when setting
attributes on them) so instead we use the sibling index. Since we
track all the additions and removals of nodes within our drop
target node, we can know exactly that the 4th node before Eclipse
reparses will correspond to the 4th node after, and so on.
Therefore, the "NodeCreationListener" interface passes not just
the nodes that were added and removed, but also the exact *index*
at which the node was added or removed. We then use this in the
code which looks up CanvasViewInfos from nodes to look up nodes
that can't be identified using the normal path.
Change-Id: Ibbf651b27ede7edfa40452de07bf1dbce02cd21e
|
| eb9180e92c97624d7d78607d61bcb0343a4db129 |
|
12-Aug-2011 |
Tor Norbye <tnorbye@google.com> |
Fix and turn on the auto-format XML option
This changeset turns on the option to "Automatically format the XML
edited by the visual layout editor" by default.
It also fixes several issues related to it:
- First, the auto-format code was previously hooked up to synchronous
insert and delete node events, which meant during a larger edit it
would apply formatting repeatedly and before the edit was complete
(which made the DOM model keep reparsing to update document based
back into its internal model).
- Another problem was that the auto format only applied to added and
removed nodes; attribute edits were not considered (which made sense
given that the old formatter did not support reordering of
attributes, but now that it does attribute changes requires
reformatting as well.)
- The old reformatter was trying to work with the Eclipse XML
formatter, which does not handle partial document formats well
(there were a bunch of workarounds, and even with those there were
some problems). The new formatter does not, so I've changed the
option to be tied to the custom formatter; the automatic formatting
of layout editor changes is now enabled only when the custom editor
is enabled.
This also takes advantage of the new formatter's ability to only
format the attributes section of a document, so if you just tweak
the attribute of a node, the children's formatting is not affected.
- The formatter would apply to more than just the layout editor; any
UI editor which used UiElementNodes would be affected. I've added a
method, by default false, where each UI editor can opt into this.
I'd like to get Raphael's feedback on the manifest editor before
possibly adding it for that editor as well (and updating the option
name to something more generic).
- The mechanism for ignoring XML document changes (already used for
refactoring) is now also connected to reformatting, so when the
formatter runs it sets an "ignore" flag such that there is no
second XML model loading when the changes are just as a result
of a formatting option.
This changeset also tweaks the formatting behavior of comments;
instead of -always- adding a blank line before line comments (other
than suffix comments), it now considers the previous document and
preserves the spacing used there (though it will collapse multiple
lines into one).
Change-Id: I04c2b80836c4d9874dca789c2f2cbc8c8c7cfa76
|
| f47a94df281ac0a65ff77cc9fd8f4787c2bb9080 |
|
18-Aug-2011 |
Raphael Moll <ralf@android.com> |
ADT: Fix issue 18689 (can't edit/save minSdkVersion)
This actually fixes the issue directly, not by a side effect.
For some weird reason, I was always creating UI nodes for
unknown attributes with a setDirty(true). That's obviously
wrong, the attribute should not be set dirty when created
but only when a value is assigned to it, if needed.
Change-Id: I4d4b6dbbc0ab7e837a772994b3e6bf6c2236de65
|
| 2914952cf3b5bad8292c0ce161a70baccfea9c3a |
|
29-Jul-2011 |
Tor Norbye <tnorbye@google.com> |
Add a new XML formatter, new options, and format on save
This changeset adds a custom XML formatter for the Android XML
editors.
There is an option for turning off this formatter and using the
standard XML formatter instead.
The new custom formatter offers the following features:
* By default, it formats files following the Android conventions for
XML formatting. This means not only that it indents with 4 space
characters (instead of the Eclipse default of one tab character),
but it places attributes on a line of their own, it adds blank
lines in certain places, and so on.
* It sorts attributes (logically, alphabetically, or none)
* It formats files with different styles depending on the context.
For example, in layout files it always places a single blank line
between view elements, whereas in manifest files it only places
blank lines between elements of different types such that for
example the <uses-permission> elements all form a logical group,
separated from <uses-sdk> and so on.
The fact that strings.xml and layout.xml are usually formatted with
different flavors is one of the reasons setting up the old Eclipse
XML formatter to do the right thing was not possible.
In addition, there are various user options added to the Editors
preference page where you can tweak the behavior of the formatter,
such as turning off blank lines completely, controlling whether there
is a space before the > or /> closing characters, and you can also
tell the formatter to use Eclipse's indentation setting (indentation
size and whether to use spaces or tabs).
Finally, there is a new "Format on Save" option which behaves just
like Format on Save for Java files: when you press Ctrl-S to save a
file, the XML content will be formatted before the file is saved.
Change-Id: Ic6f05c768ab063b09f6f0248f60fbe8722fb149d
|
| 271993a2368361fb1f67ea9c1388a352e9df43f5 |
|
15-Jul-2011 |
Tor Norbye <tnorbye@google.com> |
Sort XML attributes logically
This changeset modifies the layout editor such that it writes
attributes in a certain order:
* id
* style
* layout_width
* layout_height
* other layout_ attributes, sorted alphabetically
* other attributes, sorted alphabetically
The layout editor will produce attributes in this order when
- New widgets are dragged into the layout
- Widgets are moved in the layout
- It will also insert attributes in the right place when they are set
as the result of (for example) using the context menu actions.
Note that this ordering is applied unconditionally - there is no user
setting to turn it off. However, note that the current behavior is
random - moving a view for example will scramble the attributes (in an
order which is related to hashkeys in a map), so the option would be
"sort attributes logically" versus "sort attributes randomly"; if we
want an option to "leave attribute order alone" that will need to be
implemented.
Limitations:
- This does not yet modify the formatter to reorganize attributes.
Thus, Ctrl-Shift-F to reformat the XML will not change attribute
order.
- It does not fix the problem that the XML model updater does not
respect the formatting settings (such as one newline per attribute)
when manipulating attributes.
This will be addressed/worked around in subsequent CLs.
Implementation Note:
The Eclipse XML model updater will unconditionally *append* any new
attributes. We take advantage of this to perform attribute sorting by
ensuring that we always insert new attributes in the right order. We
also check for existing attributes and any which fall
lexicographically later than the new attributes are removed and
reinserted in the right sequence. In order to avoid performing these
removals and additions repeatedly on a node when we set multiple
attributes, and to avoid flushing attribute changes *immediately*
(which was the case until this), we now queue up all pending attribute
values in the nodes and apply them at the end when all attribute
changes for a given node are known.
Change-Id: If39f8c29f26e281f7c6622a31e11ba49724d274a
|
| 61ba58e35e896b82cefea29ab3d5e8914ac3c823 |
|
13-Jul-2011 |
Tor Norbye <tnorbye@google.com> |
Support XML closed elements
When you create new elements (by for example dragging a view into a
layout), ADT would *always* create an open element, e.g.
<Button ...></Button>
This CL uses the element descriptors to create closed elements like
this:
<Button .../>
For elements that support children it will continue to create open
elements:
<LinearLayout ...></LinearLayout>
Change-Id: I885fc4bb2611e20d511a3a40c81e202de00b7ac2
|
| 86618cc78fb2f207c477527b4413ff234f474431 |
|
05-Jul-2011 |
Raphael Moll <ralf@android.com> |
Integrate unknown attributes in the normal UiElementNode workflow.
Somehow this should have been the default.
There's a few cases where this will allow us to simplify the code
and that will be for another CL.
Also fixes http://code.google.com/p/android/issues/detail?id=17762
Change-Id: Ieccd36f5f4042f414311f09339ed18fc73d7b122
|
| 42b2f34604a3f8e8ac191831d8f01a0498760d38 |
|
09-Jun-2011 |
Tor Norbye <tnorbye@google.com> |
Fix various warnings
I ran the latest version of findbugs on our codebase and fixed some
(not all!) of the warnings.
I also ran with Eclipse 3.7 RC3 and updated our compiler warning
settings for the new warnings that are available.
I also fixed some DOS line endings in some files (formatted with CRLF
instead of LF).
Change-Id: I9a9d34a9b60f2cb609245793815d96a4587007b0
|
| 80d9301c2e874b29889c41adb0623666cf534fa0 |
|
10-Apr-2011 |
Tor Norbye <tnorbye@google.com> |
Resize & Guideline Support
RelativeLayout now has both drop/move and resize guidelines, and
existing constraints are visualized for the selection.
LinearLayout resizing now uses weights to change the size of nodes
rather than setting width/height.
All resize operations offer guidelines to snap to their "wrap_content"
size.
Various bug fixes in related areas as well.
Change-Id: I817e34c6e67ce61cfb137eb067076d91f69f99e9
|
| cd05e93b1194c89fe9eca1ee4b999d2991334f4b |
|
15-May-2011 |
Tor Norbye <tnorbye@google.com> |
Basic fragment support
This changeset adds preliminary support for fragments:
* Add <fragment> to the palette, along with a drop handler which pops
up a class chooser to pick the Fragment class; all project
implementations of android.app.Fragment and
android.support.v4.app.Fragment are listed.
* Adds a fragment descriptor such that code completion works for
<fragment> elements
* Fix project callback such that it does not complain about a missing
class "fragment".
* Fix outline to display the name of the fragment rather than the
fragment tag name.
* This changeset also centers the label in MockViews since those are
still used to render fragments
Conflicts:
eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/descriptors/LayoutDescriptors.java
Change-Id: I6f39f0c29a0cf21799fa8a55406eeae1e3beb57f
|
| 9718ea331bfc609927b1ec2a2e7453579666fa4d |
|
13-May-2011 |
Tor Norbye <tnorbye@google.com> |
Custom View handling improvements
First and foremost, allow custom views to accept children such that
you can drag & drop children into the custom view in the outline.
Second, prevent an NPE which can occur if you drag into a layout where
the root element is a custom view.
Third, handle <view> (not <View>) better: provide a custom icon, and
inline the view class name in the outline label.
Fourth, allow double clicks (in addition to ctrl-click which is already
supported) on the custom views in the palette to allow jumping to the
custom view code.
Change-Id: I13c2bf2f4169185c9fcc893ce487f2abdac46802
Conflicts:
eclipse/plugins/com.android.ide.eclipse.adt/src/com/android/ide/eclipse/adt/internal/editors/layout/descriptors/LayoutDescriptors.java
|
| 46d0ebd2126fad6b1480fa5c8121e4638c463c73 |
|
15-May-2011 |
Tor Norbye <tnorbye@google.com> |
Basic fragment support
This changeset adds preliminary support for fragments:
* Add <fragment> to the palette, along with a drop handler which pops
up a class chooser to pick the Fragment class; all project
implementations of android.app.Fragment and
android.support.v4.app.Fragment are listed.
* Adds a fragment descriptor such that code completion works for
<fragment> elements
* Fix project callback such that it does not complain about a missing
class "fragment".
* Fix outline to display the name of the fragment rather than the
fragment tag name.
* This changeset also centers the label in MockViews since those are
still used to render fragments
Change-Id: I6e062970b335d9c95870f181ed408960978c423e
|
| ec22f92d53f4bb74313b91aa491acbfbbb6dc9ce |
|
13-May-2011 |
Tor Norbye <tnorbye@google.com> |
Custom View handling improvements
First and foremost, allow custom views to accept children such that
you can drag & drop children into the custom view in the outline.
Second, prevent an NPE which can occur if you drag into a layout where
the root element is a custom view.
Third, handle <view> (not <View>) better: provide a custom icon, and
inline the view class name in the outline label.
Fourth, allow double clicks (in addition to ctrl-click which is already
supported) on the custom views in the palette to allow jumping to the
custom view code.
Change-Id: I13c2bf2f4169185c9fcc893ce487f2abdac46802
|
| 87269bec9ec19e7308d2dc958235228dbd52827b |
|
10-Mar-2011 |
Tor Norbye <tnorbye@google.com> |
XML code completion improvements
First, fix code completion for @android: resources such that if you
type @android: the various resource types (@android:drawable/,
@android:layout/, etc) are offered.
Second, fix completion for the @android: token itself such that if you
type "@a" then "@android:" is offered as a completion.
Finally, make resource name completion work even for attributes that
aren't marked in the metadata as allowing resource references. This
will not be done for empty completion context, but if the user
-explicitly- types a "@" in the value field, then resource completion
will work. This is necessary for some attributes where our metadata is
wrong, such as android:minHeight, where code completion currently
refuses to complete a @dimen/ completion prefix.
Change-Id: I175c8f7230d56987b9a945a2b791a2eb3e018a7c
|
| 21f09980161e25938619f614e768745247258657 |
|
11-Mar-2011 |
Raphael Moll <ralf@android.com> |
Avoid repeating manifest element names.
In the manifest form tree, avoid repeating element names
in the tree labels. E.g. "MyActivity (Activity)" can just
be "MyActivity".
Change-Id: I8de481aabcbc33e830e18c528cb10a0b2a14138a
|
| e7abbed2fe84c25bcd6d68cef4140963c10a1e5d |
|
31-Jan-2011 |
Tor Norbye <tnorbye@google.com> |
Add palette variations of widgets
This changeset adds new items to the palette which are just variations
of an existing widget but with different initial attributes. In
particular:
* Instead of just LinearLayout there are two versions of it:
LinearLayout (Vertical) and LinearLayout (Horizontal)
* The ProgressBar has 3 variations: Large, Small, and Horizontal. The
horizontal ProgressBar looks like the SeekBar, without at thumb, so
the SeekBar is moved next to the progress bar.
* There is a new palette category, "Text Fields", which contains a
number of different initializations of the EditText's "inputType"
attribute - for textual and numeric passwords, for names and e-mail
and postal addresses, for phone numbers, for negative and decimal
numbers, etc.
* Since LinearLayout is so common, the outline handles it specially to
ensure that we show a horizontal or a vertical icon depending on the
orientation attribute of the specific element rather than the
generic descriptor icon.
There are various changes to the palette icon preview and drag preview
etc to handle these changes. In particular, the category
initialization code had to be rewritten to be able to handle
variations (since for example the text field appears in multiple
categories, so the old assumption that each view had an assigned
category was no longer true.)
This changeset also extracts a constant for the "android:" literal
used in many places in the code, and renames the existing "android"
namespace constant.
Change-Id: Ibbc3dbd34c551594421c3de034cdccea6a66eba0
|
| 0757ce4af2764e4dd564acc0b1a013e910abc8da |
|
18-Feb-2011 |
Tor Norbye <tnorbye@google.com> |
More refactoring work: Convert hierarchy, and change type
A lot of work on the "Change Layout" refactoring to improve conversion
to a Relative Layout. First, add a "Flatten Hierarchy" option which
can take an entire hierarchy of layout widgets and flatten it down to
a single top level RelativeLayout where the constraints attempt to
reflect the original layout. (This isn't always possible, since some
layout managers offer features not possible to express in
RelativeLayout, such as a LinearLayout with multiple different
weights) but it often works or is at least a good start. (This work
is ongoing, but since my changeset is getting large I want to check in
this snapshot since the functionality is better than what is in the
trunk.)
This changeset also adds a new refactoring: Change Widget Type. This
can be applied to a selection of elements, and it will convert the
widget type to the new target widget type. It will also remove any
attributes that are not valid for the new layout.
It also improves the wizards which display the possible target types.
For Change Widget Type, it will first offer "related" widgets, so for
an AnalogClock it will first offer Digital Clock, for a checkbox it
will offer a checked text view and a radio button, etc.
In addition, it will list Views and Layouts that it finds in any
library jars (except for the builtin Android ones), and any custom
view classes in the project.
There is also now some preliminary support for refactoring unit
tests. These tests must be run as Eclipse plugin tests, since they
utilize the XML model (and the XML model cannot be mocked). The test
infrastructure reads source XML files, applies the refactoring change
list to them, and diffs the output with the known expected output
(also stored as result XML files in the test project).
Finally, there are a number of fixes and improvements to the shared
refactoring code.
Change-Id: I0974653e530dfb4feb625e0eef8257c29d50614b
|
| 85126d918d1ea7e707f7179cd74131ff1cef6af7 |
|
11-Jan-2011 |
Tor Norbye <tnorbye@google.com> |
Changes to widget text and id format
This changeset changes the default text and id attributes of newly
dropped widgets in the following ways:
1. Use the node class name rather than the id as the initial text. In
other words, the default label for a button is "Button" rather than
"@+id/Button01". This is a more common convention in other GUI
builders, and you typically don't want the actual label to be
"@+id"-something, you want it to be "@string"-something, so the @id
prefix is slightly confusing for beginners.
2. The id uses method name capitalization rather than class name
capitalization, e.g. "checkBox" rather than "CheckBox". This seems
to be the convention I see in handwritten layouts, which makes
sense given that the reference will be compiled to and referenced
as a Java field.
3. In the case of conflicts, don't use a leading 0; in other words,
rather than button01, button02, button03 we have button1, button2,
button3. It's unlikely that the user will have ten or more unnamed
widgets (and if they do the leading zero still isn't needed.) The
code which looks for name conflicts now also performs case
insensitive comparisons.
Change-Id: Ie7f2c5dd8e9852acec2c2e154ee20142b8ece9a6
|
| 1f34a9b0c5cdd41dad23719898d5f71f3ee57394 |
|
05-Jan-2011 |
Tor Norbye <tnorbye@google.com> |
Improve the Outline contents
1. Make the outline use StyledStrings such that we can use different
colors for different elements in the outline. Use the decorations
color for the element type that follows the id.
2. For elements that define a "text" property, include the text (or a
prefix of it if it is long) in the outline. Thus, for a Button you
might see something like "Button01 - "Submit Order").
3. For elements that define a "src" property, show the
source. Therefore, for an ImageView you might see "ImageView - logo".
4. For <include> elements, show the name of the included layout.
Change-Id: Ibd4c8339ea0e03c969ccaec1a67bc64436ed67af
|
| a18a523fa3e21c78320fadd031716963b3a1c501 |
|
04-Jan-2011 |
Tor Norbye <tnorbye@google.com> |
Add "Extract As Include" refactoring
Add an "Extract As Include" action to the context menu which lets you
extract a set of selected views and move them into a separate layout
file of their own, and insert an <include> reference to the new view
in place.
You can select multiple items as well (provided they are adjacent
siblings) and in that case the newly extracted layout will use the
<merge> tag as the root element.
This changeset also adds a name validator for resource names, used
both in the new-name entry field for extracted include layouts, as
well as in the New XML File wizard. It enforces that the name (except
for the .xml suffix) is a valid Java identifier name (since otherwise
the R file will have compilation errors.)
This changeset also extracts various inlined String constants like
"xmlns", "android" (as used in namespace prefixes), "@id/" etc and
replaces them with constants.
Change-Id: I3eca8b6afd23f22ca9299ff22c614b4ffd3299bf
|
| 3f6c2e7d3f6417985aac9eb65fa0f3b5a31b2578 |
|
22-Dec-2010 |
Tor Norbye <tnorbye@google.com> |
Add Move Up/Down Actions
This changeset adds "Move Up" and "Move Down" context menu items to
the outline, as well as keyboard shortcuts for these: + and -. The
actions apply only when the Outline window has focus. Thus, to reorder
an item you can select it, then press + repeatedly to move it down in
the hierarchy or - to move it back up.
In addition, this changeset fixes a selection syncing issue which also
affected drag & drop: It will now correctly always select the target
dropped tree items after a drag or reorder.
Change-Id: I11ce4fd302e537b86a614a7cbe59f1ac47f61aa5
|
| 3dfd8112f7137821ef9191bfdd82a7f30ae52dc6 |
|
23-Nov-2010 |
Raphael Moll <ralf@android.com> |
ADT: ensure <application> is last in manifest.
ADT descriptors have no notion of XML ordering.
We modify the concept of "mandatory" descriptor to
have normal mandatory descriptors versus "mandatory last" ones.
("mandatory" elements are virtual reserved slots that are
always present in the UiModel even if they have no real
counterpart in the XML model. These elements ensure they can
be manipulated in the UI even before their XML is created.)
Then we try our best to ensure the "last" ones remain at the
end of the UiNode model. There are 2 cases:
- in UiElementNode, when constructing the UINode model when
parsing an existing XML model, we try to reorder the nodes
at the end if possible.
- in UiActions, when adding a new element to the UiModel, we
try to place it before the first "mandatory last" element.
SDK Bug 3197310
Change-Id: I6a7d9502a95ebe92ff82e07f3f3249a0d25c2154
|
| c4f75630aa293ec4027216ae0bfd2d9e6782e209 |
|
22-Nov-2010 |
Tor Norbye <tnorbye@google.com> |
Fix live manipulation of <include> elements
This changeset fixes bugs related to dragging included views around in
the canvas:
First, the <include> tag would get rewritten to <null>. This happened
because the layout editor treats the FQCN and the XML node name as
equivalent, but in the case of the include tag the FQCN was set to
null instead of "include".
Second, the "layout" attribute would not get copied because it is NOT
in the Android namespace, and the code to copy attributes ended up
with an empty-string namespace which was not handled correctly.
Third, when copied the "layout" attribute would end up with the
namespace "ns:" because the code to create attribute nodes always
created namespaced attribute nodes rather than a plain attribute node
when the namespace is null.
Change-Id: Ibd34212517615aa8ec79abe14bca765cdca525f6
|
| f85ad3e3e3f3686d0bdaa3177ed10348cf72375e |
|
16-Nov-2010 |
Raphael Moll <ralf@android.com> |
ADT: Extract AttrsXmlParser in com.android.ide.common
This is a pure-refactoring CL that moves AttrsXmlParser
into an ide.common.resources.platform package. In a next CL,
the parser should be cleanup to remove some references to
external classes (e.g. adtplugin is only used for logging so
it will become an ILog reference.)
The goal of the resources.platform package is to allow other IDEs
to parse the manifest schema. An utility class would be provided
here that would then be used by AndroidTargetParser. The rest of the
data parsing (widgets, resources, etc.) is a non-goal. Maybe later.
Change-Id: I4fb8eb5d168b75ef8bfab57d0b2883aea85b6167
|
| 3bd8ee3a9447003224d34bf19328209d6b14d9ad |
|
05-Nov-2010 |
Tor Norbye <tnorbye@google.com> |
Add autoformatting of XML, and improved manual formatting
This changeset improves the formatting of XML edited by the layout
editor in two ways:
(1) It improves the way the layout editor handles insertion and
deletion into the XML document; it looks up the indentation of the
sibling and parent elements and attempts to correctly indent new
elements based on the existing surrounding formatting, and it also
attempts to clean things up correctly on element deletion.
(2) It adds a new user option for turning on automatic XML
formatting. When this is on, it will invoke the Eclipse XML formatter
on portions of the XML after each edit. This will ensure that the
document adheres to the user's preferred formatting settings (maximum
line width, tabs versus spaces, line breaks before attributes, etc.
Change-Id: I74f9a4240a8c5ca4295c01f3b55751ef10b1c1b0
|
| 71cd1869db92b5411f1a3c2dadb2f369863db0ee |
|
05-Nov-2010 |
Tor Norbye <tnorbye@google.com> |
Remove deprecated UiElementNode "editData" property
As requested in another review (#18753) the editData property on
UiElementNodes is obsolete (it was used by GLE1) and should be
removed. While there I also updated the naming style of local vars in
that class from underline to camelcase.
Change-Id: Ic5c50d07abedb1177cd018c866901f1e54cd0ec5
|
| 2a6dd1206b3cec798d3c78a78261986635b31973 |
|
04-Nov-2010 |
Tor Norbye <tnorbye@google.com> |
Fix XML editing whitespace handling
This changeset fixes three problems related to the way whitespace is
handled by the visual editor.
(1) The editor would insert a newline text node after a newly inserted
element, but this element was appended rather than inserted
immediately after the element, which meant that if you inserted your
element anywhere in the *middle* of the child list, you would
accumulate blank lines at the end of the parent's element and have no
separator before the current element.
The fix is simple - use insertBefore() rather than appendChild() when
inserting the new node.
(2) On deletion, no XML text nodes were deleted. This means that if
you inserted 4 elements, then deleted them, you would end up with 4
blank text nodes.
The fix here is to look at the sibling when we are about to delete,
and if it looks like a pure whitespace node, remove it as well.
(3) When nested content (like a LinearLayout) was inserted, there
would be no newline inserted before the child, so that first element
would end up on the same line as the parent.
The fix here is to detect this scenario (when we are inserting an
element into an element that has no children) and insert a newline
*before* the element (as well as after, as is the case for all newly
inserted elements).
Longer term we should do more advanced things with formatting, such as
indenting nested content, and making sure that when we insert and
remove whitespace nodes we always adjust the indentation
correctly. But for now, this changeset makes the XML generated by the
editor much more readable and consistent.
Change-Id: I2e65152568092a775074a606e3f5e54c680611c6
|
| 0433222f1351b565d78952e1bb8809528c0e352a |
|
27-Oct-2010 |
Tor Norbye <tnorbye@google.com> |
Add dictionary to codebase
Eclipse has the ability to spellcheck comments, and it ships with an
English dictionary. However, many valid terms in our codebase is not
in this dictionary. This checkin adds a dictionary file which contains
many of the valid spelling words used in our codebase.
(Unfortunately, Eclipse does not support "project dictionaries" like
some other IDEs where individual user dictionaries are merged with
shared project dictionaries. However, this new dictionary should be
useful for developers who use a dedicated workspace for Android
development.)
This changeset also fixes some typos.
Change-Id: Ied6647f6cb550460c0087498f8c94fa6624e3b4e
|
| 2be70bde5a6dcd6447c32ef55866020be372f96c |
|
18-Oct-2010 |
Tor Norbye <tnorbye@google.com> |
Port layout rules to Java
We had a number of layout implementations in the tool written in
Groovy; these were hard to deal with because of lack of good tool
support (debugging didn't work, refactoring didn't work, code
completion didn't (always) work, go to declaration didn't work,
semantic checks like unused code didn't work, etc. etc.)
Since these layout helpers are only getting larger, replace them by
equivalent Java code to make development easier.
This checkin also moves the API classes formerly used by Groovy
scripts into a new package (next to the Java layout rules) under
com.android.ide.common (api and layout) since this code isn't Eclipse
specific and could be used by other IDE vendors.
These interfaces were left identical (only the package statements and
directory location changed), with two exceptions: I added a new method
called "in" to IAttributeInfo.java, and I added a parameter to
IViewRule's onInitialize method.
The Groovy code was kept as close to the original as possible; I
copied in the Groovy code, and then replaced the Groovy-specific
constructs (closure-iteration on collections, literal map syntax, etc)
with equivalent Java code. The only tricky part was ensuring that
Groovy's handling of the == and != operators were translated into
.equals calls.
Change-Id: Idf7660ddea3766eac0a4a65ce6524d3f5119f7b2
|
| 13bbd4f3631ee307bad27b0a6332997386dc9ba3 |
|
08-Sep-2010 |
Raphael Moll <ralf@android.com> |
GLE2: perform all context menu edits in the same undo session.
Change-Id: I9516066edaa1704725ab234f1a65664d5eabfb39
|
| d784a5000d432260f9efe0ce5f62177f38dba6be |
|
21-Jul-2010 |
Raphael Moll <ralf@android.com> |
ADT GLE2: Properly handle empty documents, including drag'n'drop.
This makes it possible to drop into empty documents.
Change-Id: I512d8ff5e8747e4d3f5e27900308157e75cacd57
|
| f6ad088e2c38b663fd1b0408ca78a05bd4852f05 |
|
02-Jul-2010 |
Raphael Moll <ralf@android.com> |
ADT: Fix NPE in resource editor on Eclipse 3.6
SDK Bug: 2814467
The fix is a workaround around Eclipse issue
https://bugs.eclipse.org/bugs/show_bug.cgi?id=318108
Change-Id: I5684db244d5663ffa47407bd356a5bd233578612
|
| c4e3431fab6279bf4d7a2a0a9dac79a35d457c65 |
|
11-Jun-2010 |
Raphael Moll <ralf@android.com> |
ADT: Refactor AndroidEditor into AndroidXmlEditor.
Next we'll introduce a new AndroidTextEditor base class.
Change-Id: I2cdf4c7cb7a2eec03f7c523294a14f98bfd072f8
|
| 953aeea61efb31402198b969478d1bda5dcbe613 |
|
09-Jun-2010 |
Raphael Moll <ralf@android.com> |
ADT GLE2: Access AttributeInfo from groovy scripts.
This CL extracts IAttributeInfo from DeclareStyleable -- this used
to be the metadata extracted from an attribute declared in attrs.xml.
The interface that is now available to groovy scripts lets them
check whether an attribute is a reference, a string, etc. For an
enum or flag that means having access to the defined values too.
In the case of the AbsoluteLayout drop, we use this info to check if
an attribute is a reference. For example when duplicating a
RelativeLayout dropped in an AbsoluteLayout, we need to create new
ids and the RelativeLayout is prone to have inner self-references
that can be automatically adjusted that way.
A large part of the CL is about refactoring the various manually-created
attributes in the Descriptors for resources, XML, and such. In this
case the IAttributeInfo that is made available via the AttributeDescriptor
is not used, but it made sense to keep this consistent in case we want
to expose it later and to avoid having to care about special cases.
Change-Id: Ic02f69bc16f0e549fcac3956ae93b86651c5be3c
|
| c2b0492f49775b23072032d639879a77b41b1392 |
|
01-Jun-2010 |
Raphael Moll <ralf@android.com> |
ADT GLE2: Script for AbsoluteLayout for new canvas drag API.
Most of the changes concern the supporting API (INode and co)
to be able to recreate and mofiy the XML elements.
Change-Id: I9ab62b3fe125faed1b647f1735f8ff0afd33a5d9
|
| 6845b5679bbd6480eac600d56458517bcbbad609 |
|
16-Mar-2010 |
Raphael <raphael@google.com> |
ADT fix: Manifest editor doesn't reload properly on SDK change.
Cause: typo due to autocompletion.
SDK Bug 2517314
Change-Id: I81b285b5d5c7781ea0c4e18e500a5d72fb29d994
|
| 6f49708d1896bcde13ce6bea0b2a704a5de115df |
|
13-Mar-2010 |
Raphael <raphael@google.com> |
ADT GLE: treat all unknown layout XML nodes as base View objects.
This adds an interface that UIElementNode queries when it needs
to treat an unknown XML local name. The default is to create
ElementDescriptors, but layout overrides this to deal with
custom view and to create base View descriptors by default.
Change-Id: I639fb169a6b1b53b28715c88f9a037426d7ca88f
|
| c938e18817f661db5734b72f37740295631d0fcf |
|
27-Feb-2010 |
Raphael <raphael@google.com> |
ADT GLE2: Support for drop on RelativeLayout children.
Change-Id: I6ed9f1d89f61caf6141f23708854a01247ab5518
|
| d4963dc4347c871be5faa76920709001490e1d2a |
|
24-Feb-2010 |
The Android Open Source Project <initial-contribution@android.com> |
snapshot
|
| e13151727c63786342cddc3ea355425582bd4e7a |
|
13-Jan-2010 |
The Android Open Source Project <initial-contribution@android.com> |
android-2.1_r1 snapshot
|
| 4b26e04436587890f9245eda631f643d21f28d0d |
|
26-Dec-2009 |
Raphael <raphael@google.com> |
ADT GRE (Groovy Rules Engine), part 1.
This CL adds the new "Groovy Rules Engine" (GRE) to the GLE2.
The rules engine can load groovy files located in the ADT
namespace or the project associated with the current GLE2.
Each groovy file defines a class with callbacks invoked
by the LayoutCanvas.
Project rules are reloaded when they change.
Change-Id: I168234da739b2120374d3eb4552169f7dd36439d
|
| 312c9ed171a7fff530b3b7a4e6a87ead9b0d6522 |
|
13-Nov-2009 |
Jean-Baptiste Queru <jbq@google.com> |
eclair snapshot
|
| 370938d215696af14c7a7673b66b0092434b16e7 |
|
01-Oct-2009 |
Raphael <raphael@google.com> |
ADT Manifest Editor: Fix for uses-sdk dup that won't go away.
It was a display issue only, meaning the actual XML node was
being deleted but the Ui model was not updated properly. The
actual cause is that this is a mandatory node, and mandatory
nodes must stay as "fake nodes" in the Ui model. However
only one such node needs to stay in the hierarchy.
SDK BUG 2147112
Change-Id: I68e3d343bb95169865ad8dcad77004cbd51fafc3
|
| f6317f204522a2e491e3f83131b3e901e662df81 |
|
02-Sep-2009 |
Raphael <raphael@google.com> |
ADT GLE: change error display to a separate sash.
This allows GEP to display both the latest error and the latest
successful rendering. The error still needs an icon and the
canvas will need to be grayed or something.
Also the LayoutCanvas will directly use the ILayoutResult and we
won't need to custom EditData in UiElementNode so the correspond
method is @deprecated (but obviously still supported for GLE1.)
Change-Id: Ia3afed836755dbd84a4511eaed0782c85a383ac9
|
| 69425d803b34589309a69eddc53a338e1409b30c |
|
14-May-2009 |
Xavier Ducrohet <xav@android.com> |
ADT: Move more packages into internal:
editors -> adt.internal.editors.
This also marks the final refactoring of combining previous editors/common
plugin under the adt package.
|